@okfit/engine 0.6.0 → 0.7.1

package/render/json.js

@@ -1,7 +1,9 @@
+import { DistributionField } from "./distribution.js";
 import { tally } from "./exit.js";
+import { ENGINE_VERSION } from "../version.js";
 import { sort } from "./sort.js";
 import { DiagnosticRange, DiagnosticSeverity } from "@okfit/core";
-import { Schema } from "effect";
+import { Runtime, Schema } from "effect";
 
 //#region src/render/json.ts
 /** One entry of the `diagnostics` array (K-21). @public */
@@ -29,18 +31,23 @@ const JsonSummary = Schema.Struct({
 /**
 * K-21's success envelope, snake_case. `exit_code` is `0 | 1 | 2` only: an
 * infrastructure failure never produces this envelope, it produces the
-* `JsonErrorEnvelope` (K-22). `okfit_version` names the version of the
-* package that produced the report (J-2), so the CLI and the MCP server
-* legitimately report different numbers over one bundle; `producer` names
-* that package (`okfit` or `@okfit/mcp`) so the difference reads as two
-* producers, not as drift (okfit #75).
+* `JsonErrorEnvelope` (K-22). `okfit_version` and `producer` identify the
+* PACKAGE that produced the report (J-2), so the CLI and the MCP server
+* legitimately report different numbers over one bundle without that
+* reading as drift (okfit #75); `engine_version` and `okf_version` are the
+* pair that determines the report's content and the pair a reader should
+* actually compare across two producers. `distribution` names the
+* meta-package the bins were installed through (`@okfit/plugin`), or `null`
+* for a direct install of `@okfit/cli`/`@okfit/mcp` (okfit #137).
 *
 * @public
 */
 const JsonEnvelope = Schema.Struct({
 	schema: Schema.Literal(1),
 	okfit_version: Schema.String,
+	engine_version: Schema.String,
 	producer: Schema.String,
+	distribution: DistributionField,
 	okf_version: Schema.String,
 	root: Schema.String,
 	profile: Schema.NullOr(Schema.String),
@@ -52,11 +59,20 @@ const JsonEnvelope = Schema.Struct({
 	summary: JsonSummary,
 	diagnostics: Schema.Array(JsonDiagnostic)
 });
-/** K-22's envelope: the ONLY thing stdout carries under `--format json` on an exit-3 failure. @public */
+/**
+* K-22's envelope: the ONLY thing stdout carries under `--format json` on an
+* infrastructure failure. `exit_code` is `3` for most errors, or `64` for the
+* usage-tier errors (`SyncStagedLogError`, `VerifySelectionError`) that carry
+* their own `[Runtime.errorExitCode]`.
+*
+* @public
+*/
 const JsonErrorEnvelope = Schema.Struct({
 	schema: Schema.Literal(1),
 	okfit_version: Schema.String,
-	exit_code: Schema.Literal(3),
+	engine_version: Schema.String,
+	distribution: DistributionField,
+	exit_code: Schema.Literals([3, 64]),
 	error: Schema.Struct({
 		tag: Schema.String,
 		message: Schema.String
@@ -86,7 +102,9 @@ const json = (input) => {
 	return {
 		schema: 1,
 		okfit_version: input.okfitVersion,
+		engine_version: ENGINE_VERSION,
 		producer: input.producer,
+		distribution: input.distribution ?? null,
 		okf_version: input.okfVersion,
 		root: input.root,
 		profile: input.profile,
@@ -117,11 +135,25 @@ const messageOf = (error) => {
 	}
 	return String(error);
 };
+/**
+* The `[Runtime.errorExitCode]` marker's value when it is present and is one
+* of the two exit codes the JSON error envelope can carry; `3` otherwise
+* (the envelope's own default, distinct from `Runtime.getErrorExitCode`'s
+* process-level default of `1`).
+*/
+const exitCodeOf = (error) => {
+	if (typeof error === "object" && error !== null && Runtime.errorExitCode in error) {
+		if (error[Runtime.errorExitCode] === 64) return 64;
+	}
+	return 3;
+};
 /** K-22. `tag` is the error's `_tag` when it has one, else its constructor name. @public */
-const jsonError = (error, okfitVersion) => ({
+const jsonError = (error, okfitVersion, distribution) => ({
 	schema: 1,
 	okfit_version: okfitVersion,
-	exit_code: 3,
+	engine_version: ENGINE_VERSION,
+	distribution: distribution ?? null,
+	exit_code: exitCodeOf(error),
 	error: {
 		tag: tagOf(error),
 		message: messageOf(error)

package/render/stale.js

@@ -1,3 +1,5 @@
+import { DistributionField } from "./distribution.js";
+import { ENGINE_VERSION } from "../version.js";
 import { DateTime, Schema } from "effect";
 
 //#region src/render/stale.ts
@@ -24,7 +26,9 @@ const StaleSummary = Schema.Struct({
 const StaleEnvelope = Schema.Struct({
 	schema: Schema.Literal(1),
 	okfit_version: Schema.String,
+	engine_version: Schema.String,
 	producer: Schema.String,
+	distribution: DistributionField,
 	okf_version: Schema.String,
 	root: Schema.String,
 	profile: Schema.NullOr(Schema.String),
@@ -42,7 +46,9 @@ const StaleEnvelope = Schema.Struct({
 const staleEnvelope = (input) => ({
 	schema: 1,
 	okfit_version: input.okfitVersion,
+	engine_version: ENGINE_VERSION,
 	producer: input.producer,
+	distribution: input.distribution ?? null,
 	okf_version: input.okfVersion,
 	root: input.root,
 	profile: input.profile,

package/render/sync.js

@@ -1,3 +1,5 @@
+import { DistributionField } from "./distribution.js";
+import { ENGINE_VERSION } from "../version.js";
 import { SkipReason } from "../sync/run.js";
 import { Schema } from "effect";
 
@@ -26,6 +28,8 @@ const SyncModeEnvelope = Schema.Struct({
 const SyncEnvelope = Schema.Struct({
 	schema: Schema.Literal(1),
 	okfit_version: Schema.String,
+	engine_version: Schema.String,
+	distribution: DistributionField,
 	root: Schema.String,
 	dry_run: Schema.Boolean,
 	exit_code: Schema.Literal(0),
@@ -52,6 +56,8 @@ const toModeEnvelope = (mode) => ({
 const syncEnvelope = (input) => ({
 	schema: 1,
 	okfit_version: input.okfitVersion,
+	engine_version: ENGINE_VERSION,
+	distribution: input.distribution ?? null,
 	root: input.root,
 	dry_run: input.dryRun,
 	exit_code: 0,

package/render/verify.js

@@ -1,3 +1,5 @@
+import { DistributionField } from "./distribution.js";
+import { ENGINE_VERSION } from "../version.js";
 import { Schema } from "effect";
 
 //#region src/render/verify.ts
@@ -13,6 +15,8 @@ import { Schema } from "effect";
 const VerifyEnvelope = Schema.Struct({
 	schema: Schema.Literal(1),
 	okfit_version: Schema.String,
+	engine_version: Schema.String,
+	distribution: DistributionField,
 	id: Schema.String,
 	path: Schema.String,
 	verified: Schema.Struct({
@@ -33,6 +37,8 @@ const VerifyEnvelope = Schema.Struct({
 const verifyEnvelope = (input) => ({
 	schema: 1,
 	okfit_version: input.okfitVersion,
+	engine_version: ENGINE_VERSION,
+	distribution: input.distribution ?? null,
 	id: input.id,
 	path: input.path,
 	verified: {
@@ -42,6 +48,50 @@ const verifyEnvelope = (input) => ({
 	dry_run: input.dryRun,
 	exit_code: 0
 });
+/**
+* Issue #138's batch success envelope, schema 1, the same snake_case
+* convention as `VerifyEnvelope`. `concepts` carries every concept
+* `okfit verify --all`/`--type` attested (or would attest under a dry run),
+* in write order; `skipped` carries every candidate it declined, with why.
+*
+* @public
+*/
+const VerifyBatchEnvelope = Schema.Struct({
+	schema: Schema.Literal(1),
+	okfit_version: Schema.String,
+	engine_version: Schema.String,
+	distribution: DistributionField,
+	verified_by: Schema.String,
+	verified_at: Schema.String,
+	concepts: Schema.Array(Schema.Struct({
+		id: Schema.String,
+		path: Schema.String
+	})),
+	skipped: Schema.Array(Schema.Struct({
+		id: Schema.String,
+		reason: Schema.Literals(["draft", "already-verified"])
+	})),
+	dry_run: Schema.Boolean,
+	exit_code: Schema.Literal(0)
+});
+/**
+* `concepts[].path` is already the display form, the same convention
+* {@link verifyEnvelope} uses for its own `path`.
+*
+* @public
+*/
+const verifyBatchEnvelope = (input) => ({
+	schema: 1,
+	okfit_version: input.okfitVersion,
+	engine_version: ENGINE_VERSION,
+	distribution: input.distribution ?? null,
+	verified_by: input.by,
+	verified_at: input.at,
+	concepts: input.concepts,
+	skipped: input.skipped,
+	dry_run: input.dryRun,
+	exit_code: 0
+});
 
 //#endregion
-export { VerifyEnvelope, verifyEnvelope };
+export { VerifyBatchEnvelope, VerifyEnvelope, verifyBatchEnvelope, verifyEnvelope };

package/sync/generated.js

@@ -1,5 +1,5 @@
-import { detectNewline, locateGenerated, locateGeneratedBodySha256, stripBom } from "../verify/locate.js";
-import { spliceGeneratedFields } from "../verify/splice.js";
+import { detectNewline, locateGenerated, locateGeneratedBlock, locateGeneratedBodySha256, stripBom } from "../verify/locate.js";
+import { spliceGeneratedBlock, spliceGeneratedFields } from "../verify/splice.js";
 import { writeAtomic } from "./write.js";
 import { Timestamp } from "@okfit/core";
 import { Effect, FileSystem, Path, Schema } from "effect";
@@ -28,14 +28,21 @@ const GeneratedSkipReason = Schema.Literals([
 ]);
 const encodeAt = Schema.encodeSync(Timestamp);
 /**
-* Contract §6.2's twelve-step algorithm, run once per `bundle.concepts`
-* entry (S-22: `index.md`/`log.md` are reserved files, never concepts,
-* never seen here). `provenance` is the single `Derivation.generatedAt`
-* walk `runSync` (Task B3) computes once and shares with log mode; this
-* function never calls git itself and never substitutes `now` for an
-* uncommitted body (design §3 rule 2). Every write is atomic (temp file
-* plus rename in the same directory), matching `verify`'s own discipline
-* (`verify/run.ts`'s `runVerify`).
+* Contract §6.2's algorithm, run once per `bundle.concepts` entry (S-22:
+* `index.md`/`log.md` are reserved files, never concepts, never seen here).
+* `options.provenance` is the single `Derivation.generatedAt` walk `runSync`
+* (Task B3) computes once and shares with log mode; this function never
+* calls git itself and never substitutes `now` for an uncommitted body
+* (design §3 rule 2). Every write is atomic (temp file plus rename in the
+* same directory), matching `verify`'s own discipline (`verify/run.ts`'s
+* `runVerify`).
+*
+* Ordering (later tasks rely on it): (1) scope filter -> (2) digest match
+* against `generated.body_sha256` => `unchanged`, BEFORE any provenance
+* lookup -> (3) provenance absent => `Effect.die` (caller contract) -> (4)
+* `uncommitted` => skipped with its reason -> (5) no `generated` block:
+* `agent` unset => skipped `generated-missing`, else create -> (6) existing
+* block: splice `at` + `body_sha256` as today.
 *
 * `locateGenerated`'s `YamlParseError` is folded into a defect here
 * (`Effect.orDie`), not widened into this function's typed error channel:
@@ -50,13 +57,21 @@ const encodeAt = Schema.encodeSync(Timestamp);
 *
 * @internal
 */
-const syncGenerated = Effect.fn("okfit/sync/syncGenerated")(function* (bundle, provenance, dryRun) {
+const syncGenerated = Effect.fn("okfit/sync/syncGenerated")(function* (bundle, options) {
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
+	const { provenance, dryRun, agent, scope } = options;
 	const written = [];
 	const unchanged = [];
 	const skipped = [];
 	for (const [id, concept] of bundle.concepts) {
+		if (scope !== void 0 && !scope.has(id)) continue;
+		const generated = concept.frontmatter.generated;
+		const currentDigest = yield* Derivation.bodyDigest(concept.document.source);
+		if (generated?.body_sha256 !== void 0 && generated.body_sha256 === currentDigest) {
+			unchanged.push(id);
+			continue;
+		}
 		const derived = provenance.get(id);
 		if (derived === void 0) return yield* Effect.die(/* @__PURE__ */ new Error(`syncGenerated: no provenance computed for concept ${id}`));
 		if (derived._tag === "uncommitted") {
@@ -66,34 +81,46 @@ const syncGenerated = Effect.fn("okfit/sync/syncGenerated")(function* (bundle, p
 			});
 			continue;
 		}
-		const generated = concept.frontmatter.generated;
-		if (generated === void 0) {
+		const creating = generated === void 0 ? agent : void 0;
+		if (generated === void 0 && creating === void 0) {
 			skipped.push({
 				id,
 				reason: "generated-missing"
 			});
 			continue;
 		}
-		const currentDigest = yield* Derivation.bodyDigest(concept.document.source);
-		if (generated.body_sha256 !== void 0 && generated.body_sha256 === currentDigest) {
-			unchanged.push(id);
-			continue;
-		}
 		const absolutePath = path.join(bundle.root, concept.path);
 		const source = yield* fs.readFileString(absolutePath);
 		const { text, bom } = stripBom(source);
 		const newline = detectNewline(text);
-		const atLocated = yield* locateGenerated(text).pipe(Effect.orDie);
-		const bodySha256Located = yield* locateGeneratedBodySha256(text).pipe(Effect.orDie);
-		if (atLocated._tag === "unsupported" || bodySha256Located._tag === "unsupported") {
-			skipped.push({
-				id,
-				reason: "generated-unsupported"
-			});
-			continue;
-		}
 		const encodedAt = encodeAt(derived.at);
-		const edits = spliceGeneratedFields(atLocated, bodySha256Located, encodedAt, currentDigest, newline);
+		let edits;
+		if (creating !== void 0) {
+			const located = yield* locateGeneratedBlock(text).pipe(Effect.orDie);
+			if (located._tag === "unsupported") {
+				skipped.push({
+					id,
+					reason: "generated-unsupported"
+				});
+				continue;
+			}
+			edits = [spliceGeneratedBlock(located, {
+				by: creating,
+				at: encodedAt,
+				bodySha256: currentDigest
+			}, newline)];
+		} else {
+			const atLocated = yield* locateGenerated(text).pipe(Effect.orDie);
+			const bodySha256Located = yield* locateGeneratedBodySha256(text).pipe(Effect.orDie);
+			if (atLocated._tag === "unsupported" || bodySha256Located._tag === "unsupported") {
+				skipped.push({
+					id,
+					reason: "generated-unsupported"
+				});
+				continue;
+			}
+			edits = spliceGeneratedFields(atLocated, bodySha256Located, encodedAt, currentDigest, newline);
+		}
 		const finalText = bom + MarkdownEdit.applyAll(text, edits);
 		if (dryRun) {
 			written.push(id);

package/sync/log.js

@@ -63,15 +63,35 @@ const mergeLog = (existing, additions) => {
 	});
 	return dates.length === 0 ? `# ${title}\n` : `# ${title}\n\n${pieces.join("")}`;
 };
+/** @internal */
+const logWindow = (doc, since) => {
+	const groups = doc?.groups ?? [];
+	const newest = groups.map((entryGroup) => entryGroup.date).reduce((max, date) => max === void 0 || date > max ? date : max, void 0);
+	const named = /* @__PURE__ */ new Map();
+	for (const entryGroup of groups) named.set(entryGroup.date, new Set(entryGroup.items.map((item) => item.text)));
+	return {
+		since: since ?? newest,
+		named
+	};
+};
+/** @internal */
+const wantsLogEntry = (window, date, title) => {
+	if (window.since !== void 0 && date < window.since) return false;
+	const items = window.named.get(date);
+	return items === void 0 || !(items.has(`Added ${title}`) || items.has(`Updated ${title}`));
+};
 /**
 * 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).
+* `Updated index`/`Updated log` line can never occur). Issue #18: the
+* selection window defaults to the newest logged date (inclusive), so a
+* concept committed the same day as an existing group is appended into it
+* rather than dropped; an explicit `since` replaces that default floor.
 *
 * @internal
 */
-const syncLog = Effect.fn("okfit/sync/syncLog")(function* (bundle, provenance, dryRun) {
+const syncLog = Effect.fn("okfit/sync/syncLog")(function* (bundle, provenance, dryRun, since) {
 	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)));
@@ -85,16 +105,17 @@ const syncLog = Effect.fn("okfit/sync/syncLog")(function* (bundle, provenance, d
 			reason: "log-unparseable"
 		}]
 	};
-	const newestLogged = (existingDoc?.groups ?? []).map((entryGroup) => entryGroup.date).reduce((max, date) => max === void 0 || date > max ? date : max, void 0);
+	const window = logWindow(existingDoc, since);
 	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;
+		const title = Derive.title(concept);
+		if (!wantsLogEntry(window, date, title)) continue;
 		additions.push({
 			date,
-			title: Derive.title(concept),
+			title,
 			added: derived.creating
 		});
 	}
@@ -124,4 +145,4 @@ const syncLog = Effect.fn("okfit/sync/syncLog")(function* (bundle, provenance, d
 });
 
 //#endregion
-export { mergeLog, syncLog };
+export { logWindow, mergeLog, syncLog, wantsLogEntry };

package/sync/run.js

@@ -1,9 +1,11 @@
+import { SyncStagedLogError } from "../errors.js";
 import { syncGenerated } from "./generated.js";
 import { syncIndex } from "./index.js";
-import { syncLog } from "./log.js";
-import { Bundle } from "@okfit/core";
-import { Effect, Schema } from "effect";
+import { logWindow, syncLog, wantsLogEntry } from "./log.js";
+import { Bundle, Derive } from "@okfit/core";
+import { DateTime, Effect, FileSystem, Path, Schema } from "effect";
 import { Derivation } from "@okfit/profiles";
+import { Git } from "@effected/git";
 
 //#region src/sync/run.ts
 /**
@@ -29,29 +31,75 @@ const UNSELECTED = {
 	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).
+* Contract §5's six-step algorithm: one `Bundle.load`, then a lazy
+* `Derivation.generatedAt` walk shared by the generated and log modes
+* (issue #21) — computed only for a concept that still needs one, not for
+* every concept — 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);
+	if (options.staged !== void 0 && options.modes.has("log")) return yield* new SyncStagedLogError({});
+	const walked = /* @__PURE__ */ new Map();
+	let staged;
+	let scope;
+	let repoRoot;
+	let realPaths;
+	if (options.staged !== void 0) {
+		const git = yield* Git;
+		const fs = yield* FileSystem.FileSystem;
+		const path = yield* Path.Path;
+		repoRoot = yield* fs.realPath(yield* git.repoRoot(bundle.root));
+		const stagedPaths = new Set(yield* git.stagedChanges(repoRoot));
+		const selected = /* @__PURE__ */ new Set();
+		const provenanceStaged = /* @__PURE__ */ new Map();
+		const resolvedPaths = /* @__PURE__ */ new Map();
+		for (const [id, concept] of bundle.concepts) {
+			const real = yield* fs.realPath(path.join(bundle.root, concept.path));
+			const rel = path.relative(repoRoot, real).split(path.sep).join("/");
+			if (!stagedPaths.has(rel)) continue;
+			selected.add(id);
+			provenanceStaged.set(id, {
+				_tag: "committed",
+				at: options.staged.at
+			});
+			resolvedPaths.set(id, real);
+		}
+		staged = provenanceStaged;
+		scope = selected;
+		realPaths = resolvedPaths;
+	} else if (options.modes.has("generated") || options.modes.has("log")) {
+		const window = logWindow(bundle.logs.get(""), options.logSince);
+		for (const [id, concept] of bundle.concepts) {
+			const generated = concept.frontmatter.generated;
+			const digest = yield* Derivation.bodyDigest(concept.document.source);
+			const stampedAt = generated?.body_sha256 !== void 0 && generated.body_sha256 === digest ? generated.at : void 0;
+			if (!(stampedAt === void 0 || options.modes.has("log") && wantsLogEntry(window, DateTime.formatIsoDate(stampedAt), Derive.title(concept)))) continue;
+			const derived = yield* Derivation.generatedAt({ file: `${bundle.root}/${concept.path}` });
+			walked.set(id, derived);
+		}
 	}
 	const generated = options.modes.has("generated") ? {
 		selected: true,
-		...yield* syncGenerated(bundle, provenance, options.dryRun)
+		...yield* syncGenerated(bundle, {
+			provenance: staged ?? walked,
+			dryRun: options.dryRun,
+			...options.config.actors?.agent === void 0 ? {} : { agent: options.config.actors.agent },
+			...scope === void 0 ? {} : { scope }
+		})
 	} : 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;
+	const log = options.modes.has("log") ? yield* syncLog(bundle, walked, options.dryRun, options.logSince) : UNSELECTED;
+	if (options.staged !== void 0 && !options.dryRun && repoRoot !== void 0) {
+		const path = yield* Path.Path;
+		const writtenIds = new Set(generated.written);
+		const files = [...realPaths === void 0 ? [] : Array.from(realPaths.entries()).filter(([id]) => writtenIds.has(id)).map(([, real]) => real), ...index.written.map((relative) => path.join(bundle.root, relative))];
+		if (files.length > 0) yield* (yield* Git).add(repoRoot, files);
+	}
 	return {
 		bundleRoot: options.bundleRoot,
 		dryRun: options.dryRun,

package/verify/locate.js

@@ -254,6 +254,29 @@ const locateGenerated = (source) => locateGeneratedField(source, "at");
 * @internal
 */
 const locateGeneratedBodySha256 = (source) => locateGeneratedField(source, "body_sha256");
+/** @internal */
+const locateGeneratedBlock = Effect.fn("okfit/verify/locateGeneratedBlock")(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"
+	};
+	if (contents.items.find((item) => item.key instanceof YamlScalar && item.key.value === "generated") !== void 0) return {
+		_tag: "unsupported",
+		shape: "generated-present"
+	};
+	return {
+		_tag: "absent",
+		insertAt: valueStart + value.length
+	};
+});
 
 //#endregion
-export { detectNewline, documentNewline, indentAt, locate, locateGenerated, locateGeneratedBodySha256, stripBom };
+export { detectNewline, documentNewline, indentAt, locate, locateGenerated, locateGeneratedBlock, locateGeneratedBodySha256, stripBom };