@savvy-web/silk-effects 5.7.2 → 5.8.1

package/lint/handlers/TypeScript.js

@@ -5,11 +5,11 @@ import { Filter } from "../utils/Filter.js";
 /**
 * Handler for TypeScript files.
 *
-* Runs type checking with tsgo or tsc.
+* Runs type checking with tsc or tsgo.
 *
 * @remarks
 * Type checking runs on all staged TypeScript files using the configured
-* compiler (tsgo or tsc). The compiler is auto-detected at runtime using
+* compiler (tsc or tsgo). The compiler is auto-detected at runtime using
 * `Command.findTool()`, which correctly handles pnpm catalogs, peer
 * dependencies, and hoisted/transitive deps.
 *
@@ -45,10 +45,16 @@ var TypeScript = class TypeScript {
 	* Detect which TypeScript compiler to use.
 	*
 	* Uses `Command.findTool()` to check for available compilers:
-	* 1. `tsgo` (native TypeScript) — checked first
-	* 2. `tsc` (standard TypeScript) — fallback
+	* 1. `tsc` (standard TypeScript) — checked first
+	* 2. `tsgo` (native TypeScript) — fallback
 	*
 	* @remarks
+	* `tsc` is preferred so the pre-commit gate runs the same compiler as a
+	* repo's own `types:check` task. Preferring `tsgo` meant any repo with
+	* `\@typescript/native-preview` anywhere in its dependency graph — even as
+	* a hoisted or transitive dep — silently got a different compiler for its
+	* commit gate than for its typecheck task.
+	*
 	* Unlike the previous implementation that parsed `package.json` dependencies,
 	* this uses runtime tool detection which works correctly with pnpm catalogs,
 	* peer dependencies, and hoisted/transitive deps.
@@ -58,14 +64,6 @@ var TypeScript = class TypeScript {
 	*/
 	static detectCompiler(_cwd) {
 		if (TypeScript.cachedCompilerResult !== null) return TypeScript.cachedCompilerResult.compiler;
-		const tsgo = Command.findTool("tsgo");
-		if (tsgo.available) {
-			TypeScript.cachedCompilerResult = {
-				compiler: "tsgo",
-				tool: tsgo
-			};
-			return "tsgo";
-		}
 		const tsc = Command.findTool("tsc");
 		if (tsc.available) {
 			TypeScript.cachedCompilerResult = {
@@ -74,6 +72,14 @@ var TypeScript = class TypeScript {
 			};
 			return "tsc";
 		}
+		const tsgo = Command.findTool("tsgo");
+		if (tsgo.available) {
+			TypeScript.cachedCompilerResult = {
+				compiler: "tsgo",
+				tool: tsgo
+			};
+			return "tsgo";
+		}
 	}
 	/**
 	* Check if a TypeScript compiler is available.
@@ -90,7 +96,7 @@ var TypeScript = class TypeScript {
 	* Uses the cached `ToolSearchResult` from `detectCompiler()` to build
 	* the command string, avoiding a separate package manager detection step.
 	*
-	* @returns Command string like `pnpm exec tsgo --noEmit` or `tsgo --noEmit`
+	* @returns Command string like `pnpm exec tsc --noEmit` or `tsc --noEmit`
 	* @throws Error if no TypeScript compiler is available
 	*/
 	static getDefaultTypecheckCommand() {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@savvy-web/silk-effects",
-	"version": "5.7.2",
+	"version": "5.8.1",
 	"private": false,
 	"description": "Shared Effect library for Silk Suite conventions",
 	"homepage": "https://github.com/savvy-web/systems/tree/main/packages/silk-effects",
@@ -34,13 +34,13 @@
 		"@changesets/get-github-info": "^1.0.0",
 		"@changesets/get-release-plan": "^5.0.0",
 		"@effected/commands": "^0.4.0",
-		"@effected/git": "^0.7.0",
+		"@effected/git": "^0.8.0",
 		"@effected/glob": "^0.3.0",
 		"@effected/jsonc": "^0.6.0",
-		"@effected/package-json": "^0.8.0",
+		"@effected/package-json": "^0.9.0",
 		"@effected/templates": "^0.2.0",
 		"@effected/walker": "^0.4.0",
-		"@effected/workspaces": "^0.12.0",
+		"@effected/workspaces": "^0.13.0",
 		"@effected/yaml": "^0.8.0",
 		"@manypkg/get-packages": "^3.1.0",
 		"mdast-util-heading-range": "^4.0.0",

package/pr-body/body.js

@@ -0,0 +1,145 @@
+import { Region } from "./region.js";
+import { Markers } from "./markers.js";
+import { ClosingReferences, OwnedAttribute } from "./references.js";
+
+//#region src/pr-body/body.ts
+const FENCE = "```";
+/**
+* The marker-delimited reference region, merging this run's references with
+* any an agent added.
+*
+* @remarks
+* Module-private: the region is always emitted, empty or not, so an agent
+* always has a target to write into — the same reservation the summary
+* region makes.
+*/
+const buildReferencesRegion = (args) => {
+	const known = new Set(args.linkedIssues.map((issue) => issue.number));
+	const ownedNow = ClosingReferences.fromIssues(args.linkedIssues).dedupe();
+	const agentAdded = [...new Set(ClosingReferences.parseBare(args.carriedReferences))].filter((id) => !args.previouslyOwned.has(id) && !known.has(id)).sort((a, b) => a - b);
+	const lines = ClosingReferences.make({ ids: [...ownedNow.ids, ...agentAdded] }).renderBareLines();
+	return `${`${Markers.REFERENCES_START_PREFIX} ${OwnedAttribute.render(ownedNow.ids)} -->`}\n${lines === "" ? "" : `${lines}\n`}${Markers.REFERENCES_END}`;
+};
+/**
+* The proposed squash-commit message, fenced for an AI integration to
+* rewrite.
+*
+* @remarks
+* Module-private. Carries its own `Closes` references because the squash
+* commit needs them too — a reference inside a fenced block is inert to
+* GitHub's linker, which is precisely why the plain-text lines outside it
+* are separate rather than shared.
+*/
+const buildSquashBlock = (args) => {
+	const closing = ClosingReferences.fromIssues(args.linkedIssues).renderTrailer();
+	const message = [
+		args.subject,
+		closing,
+		args.signoff
+	].filter((part) => part !== "").join("\n\n");
+	return `${FENCE}${Markers.SQUASH_FENCE_LANGUAGE}\n${message}\n${FENCE}`;
+};
+/**
+* The shared managed-PR-body renderer and its carry-through readers — the
+* single implementation of the contract `silk-release-action` dogfooded at
+* `src/utils/pr-body.ts` (savvy-web/systems#419).
+*
+* @remarks
+* Every operation is pure and total: markers absent, regions broken, or
+* attributes malformed all degrade to the documented fail-safe result
+* (preserve too much rather than delete someone's work) instead of failing —
+* a regenerating action must still produce a body when the prior one is
+* malformed. Use `PrBodyDiagnostic.scan` where a writer wants to be told
+* about a broken pair instead of tolerating it.
+*
+* @public
+*/
+var ManagedPrBody = class ManagedPrBody {
+	constructor() {}
+	/**
+	* Build the region of the PR description the generating run owns.
+	*
+	* @remarks
+	* Delimited by `Markers.MANAGED_START` / `Markers.MANAGED_END` so
+	* {@link ManagedPrBody.upsert} can regenerate it without touching
+	* anything a human wrote around it. Layout, in order: the reserved
+	* summary region (nothing may sit above it — a reader meets the prose
+	* before the machinery), the proposed-squash-commit fence, and the
+	* bare-reference region. No preamble, no file listing, no linked-issues
+	* list, no run attribution — each said something already on the page.
+	*
+	* @public
+	*/
+	static build(options) {
+		const parts = [];
+		parts.push(`${Markers.SUMMARY_START}\n${options.summary === "" ? "" : `${options.summary}\n`}${Markers.SUMMARY_END}`);
+		parts.push(buildSquashBlock({
+			subject: options.subject,
+			linkedIssues: options.linkedIssues,
+			signoff: options.signoff
+		}));
+		const priorBody = options.priorBody ?? "";
+		parts.push(buildReferencesRegion({
+			linkedIssues: options.linkedIssues,
+			carriedReferences: ManagedPrBody.extractReferences(priorBody),
+			previouslyOwned: OwnedAttribute.parse(priorBody)
+		}));
+		return `${Markers.MANAGED_START}\n${parts.join("\n\n")}\n${Markers.MANAGED_END}`;
+	}
+	/**
+	* Put `managed` (a full {@link ManagedPrBody.build} result) into
+	* `existing`, replacing a previous managed region and leaving everything
+	* else alone.
+	*
+	* @remarks
+	* Human edits outside the markers survive; a body with no markers keeps
+	* its content and gains the region below it. See `Region.upsert` for the
+	* splice semantics.
+	*
+	* @public
+	*/
+	static upsert(existing, managed) {
+		return Region.upsert(existing, "silk-release", managed);
+	}
+	/**
+	* The summary region's current content, or `""` when it is empty or
+	* absent.
+	*
+	* @remarks
+	* Extraction exists because the managed region is REGENERATED on every
+	* run. Re-emitting the region empty would delete a summary the moment
+	* any commit landed — destructive and silent, with no signal back to the
+	* summariser whose work was discarded. Feed the result to
+	* {@link ManagedPrBody.build}'s `summary` option.
+	*
+	* @public
+	*/
+	static extractSummary(existing) {
+		const from = existing.indexOf(Markers.SUMMARY_START);
+		const to = existing.indexOf(Markers.SUMMARY_END);
+		if (from === -1 || to === -1 || to < from) return "";
+		return existing.slice(from + Markers.SUMMARY_START.length, to).trim();
+	}
+	/**
+	* The reference region's current content, or `""` when it is empty or
+	* absent.
+	*
+	* @remarks
+	* Symmetric to {@link ManagedPrBody.extractSummary}, and for the same
+	* reason. Located by `Markers.REFERENCES_START_PREFIX` — never the plain
+	* opening constant — because a generating run emits the attributed form.
+	*
+	* @public
+	*/
+	static extractReferences(existing) {
+		const from = existing.indexOf(Markers.REFERENCES_START_PREFIX);
+		const to = existing.indexOf(Markers.REFERENCES_END);
+		if (from === -1 || to === -1 || to < from) return "";
+		const openEnd = existing.indexOf("-->", from);
+		if (openEnd === -1 || openEnd > to) return "";
+		return existing.slice(openEnd + 3, to).trim();
+	}
+};
+
+//#endregion
+export { ManagedPrBody };

package/pr-body/diagnostics.js

@@ -0,0 +1,104 @@
+import { Region } from "./region.js";
+import { Markers } from "./markers.js";
+import { Schema } from "effect";
+
+//#region src/pr-body/diagnostics.ts
+/**
+* The problems {@link PrBodyDiagnostic.scan} can report about a body's
+* markers.
+*
+* @public
+*/
+const PrBodyDiagnosticCode = Schema.Literals(["unpairedMarker", "duplicateMarker"]);
+/**
+* One problem with a body's silk-release markers.
+*
+* @remarks
+* Diagnostics are advisory VALUES, not a typed error channel: every parse and
+* render operation in this namespace is deliberately total (a regenerating
+* action must still produce a body when the prior one is malformed, and the
+* fail-safe direction is to preserve too much rather than delete someone's
+* work). `scan` exists for the writer that wants to be told about a broken
+* pair before editing — the `pr-body` skill instructs an agent that finds a
+* region missing its pair to stop and report rather than guess, and this is
+* the check that instruction points at. A misplaced marker pair is worse than
+* none: it makes the next regeneration rewrite content it does not own.
+*
+* @public
+*/
+var PrBodyDiagnostic = class PrBodyDiagnostic extends Schema.Class("PrBodyDiagnostic")({
+	code: PrBodyDiagnosticCode,
+	/** The region token the problem is about, e.g. `silk-release:summary`. */
+	token: Schema.String
+}) {
+	/**
+	* A human-readable description, derived from the structured fields.
+	*
+	* @public
+	*/
+	get message() {
+		return this.code === "unpairedMarker" ? `region "${this.token}" has an unpaired or out-of-order marker — its :start and :end must both be present, in order` : `region "${this.token}" appears more than once — each silk-release region must be a single pair`;
+	}
+	/**
+	* Every marker problem in `body`, or an empty array when the markers are
+	* well-formed (including entirely absent — an unmanaged body is not a
+	* defect).
+	*
+	* @remarks
+	* The references region is located by its attributed opening prefix, so a
+	* marker carrying an `owned="…"` attribute counts as present.
+	*
+	* @public
+	*/
+	static scan(body) {
+		const diagnostics = [];
+		const tokens = [
+			["silk-release", Markers.MANAGED_START],
+			["silk-release:summary", Markers.SUMMARY_START],
+			["silk-release:references", Markers.REFERENCES_START_PREFIX]
+		];
+		for (const [token, openMarker] of tokens) {
+			const opens = countOccurrences(body, openMarker);
+			const closes = countOccurrences(body, Region.end(token));
+			if (opens === 0 && closes === 0) continue;
+			if (opens !== closes) {
+				diagnostics.push(PrBodyDiagnostic.make({
+					code: "unpairedMarker",
+					token
+				}));
+				continue;
+			}
+			if (opens > 1) {
+				diagnostics.push(PrBodyDiagnostic.make({
+					code: "duplicateMarker",
+					token
+				}));
+				continue;
+			}
+			if (body.indexOf(Region.end(token)) < body.indexOf(openMarker)) diagnostics.push(PrBodyDiagnostic.make({
+				code: "unpairedMarker",
+				token
+			}));
+		}
+		return diagnostics;
+	}
+};
+/**
+* Non-overlapping occurrences of `needle` in `haystack`.
+*
+* @remarks
+* Module-private on purpose — it exists only to keep `scan` readable.
+*/
+const countOccurrences = (haystack, needle) => {
+	let count = 0;
+	let from = 0;
+	for (;;) {
+		const at = haystack.indexOf(needle, from);
+		if (at === -1) return count;
+		count += 1;
+		from = at + needle.length;
+	}
+};
+
+//#endregion
+export { PrBodyDiagnostic, PrBodyDiagnosticCode };

package/pr-body/index.js

@@ -0,0 +1,22 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { Region } from "./region.js";
+import { Markers } from "./markers.js";
+import { LinkedIssueRef } from "./linked-issue.js";
+import { ClosingReferences, OwnedAttribute } from "./references.js";
+import { ManagedPrBody } from "./body.js";
+import { PrBodyDiagnostic, PrBodyDiagnosticCode } from "./diagnostics.js";
+
+//#region src/pr-body/index.ts
+var pr_body_exports = /* @__PURE__ */ __exportAll({
+	ClosingReferences: () => ClosingReferences,
+	LinkedIssueRef: () => LinkedIssueRef,
+	ManagedPrBody: () => ManagedPrBody,
+	Markers: () => Markers,
+	OwnedAttribute: () => OwnedAttribute,
+	PrBodyDiagnostic: () => PrBodyDiagnostic,
+	PrBodyDiagnosticCode: () => PrBodyDiagnosticCode,
+	Region: () => Region
+});
+
+//#endregion
+export { ClosingReferences, LinkedIssueRef, ManagedPrBody, Markers, OwnedAttribute, PrBodyDiagnostic, PrBodyDiagnosticCode, Region, pr_body_exports };

package/pr-body/linked-issue.js

@@ -0,0 +1,44 @@
+import { Schema } from "effect";
+
+//#region src/pr-body/linked-issue.ts
+/**
+* The minimum an issue must carry to appear in a managed PR body.
+*
+* @remarks
+* `state` is deliberately a tolerant `Schema.String` rather than a literal
+* union: GitHub's REST API reports `"open"`/`"closed"` while GraphQL reports
+* `"OPEN"`/`"CLOSED"`, and both actions pass their existing issue shapes
+* through unchanged. **`LinkedIssueRef.isClosed` is the ONLY sanctioned way
+* to test closedness** — it lowercases before comparing, so both spellings
+* classify correctly. A hand-written `issue.state === "closed"` comparison
+* silently misclassifies GraphQL's `"CLOSED"` as open, which re-links (and on
+* merge auto-closes) an issue the release deliberately dropped.
+*
+* The class carries no instance members, so a plain
+* `{ number, title, state }` literal satisfies the type structurally — both
+* actions' existing `LinkedIssue` shapes are accepted without mapping.
+*
+* @public
+*/
+var LinkedIssueRef = class extends Schema.Class("LinkedIssueRef")({
+	number: Schema.Number.check(Schema.isInt()).check(Schema.isGreaterThan(0)),
+	title: Schema.String,
+	state: Schema.String
+}) {
+	/**
+	* Whether an issue is closed, case-insensitively.
+	*
+	* @remarks
+	* The only sanctioned closedness test — see the class remarks for why a
+	* bare `state === "closed"` comparison is a silent bug against GraphQL
+	* payloads.
+	*
+	* @public
+	*/
+	static isClosed(issue) {
+		return issue.state.toLowerCase() === "closed";
+	}
+};
+
+//#endregion
+export { LinkedIssueRef };

package/pr-body/markers.js

@@ -0,0 +1,103 @@
+import { Region } from "./region.js";
+
+//#region src/pr-body/markers.ts
+/**
+* The frozen `silk-release` marker vocabulary — the wire format of the shared
+* PR-body contract.
+*
+* @remarks
+* **The `silk-release:` token is frozen and names the CONTRACT, not the
+* emitting action.** `silk-update-action` PRs carry the same markers as
+* release PRs, deliberately: every live document, the `pr-body` plugin skill,
+* and every agent that edits a managed PR description key on these exact
+* byte sequences. Do not parameterize the token per action and do not rename
+* it — either forks the wire format for zero gain and orphans every open PR
+* (ruled in savvy-web/systems#419).
+*
+* These constants are the single source of truth for the marker grammar.
+* The agent-facing documentation in the silk plugin (`pr-body` and
+* `commit-create` skills) duplicates the literals for readability; a drift
+* lint in this package's test suite asserts the copies stay in sync.
+*/
+/**
+* The marker constants of the `silk-release` PR-body contract.
+*
+* @public
+*/
+var Markers = class {
+	constructor() {}
+	/**
+	* Opening marker of the whole managed region.
+	*
+	* @remarks
+	* Everything between this and {@link Markers.MANAGED_END} that is not
+	* inside the summary or references region is regenerated wholesale on
+	* every run; everything outside the pair is human territory and survives
+	* every regeneration.
+	*
+	* @public
+	*/
+	static MANAGED_START = Region.start("silk-release");
+	/**
+	* Closing marker of the whole managed region.
+	*
+	* @public
+	*/
+	static MANAGED_END = Region.end("silk-release");
+	/**
+	* Opening marker of the region an AI summariser owns.
+	*
+	* @remarks
+	* The generating action never writes into this region — it only reserves
+	* it and carries its content through on regeneration.
+	*
+	* @public
+	*/
+	static SUMMARY_START = Region.start("silk-release:summary");
+	/**
+	* Closing marker of the summariser's region.
+	*
+	* @public
+	*/
+	static SUMMARY_END = Region.end("silk-release:summary");
+	/**
+	* The PLAIN opening marker of the closing-reference region — the form an
+	* author writes by hand.
+	*
+	* @remarks
+	* A generating run emits the ATTRIBUTED form instead (the plain prefix
+	* plus an `owned="…"` attribute). Never locate the region by matching
+	* this constant — match {@link Markers.REFERENCES_START_PREFIX}, or a
+	* region a run wrote will not be found.
+	*
+	* @public
+	*/
+	static REFERENCES_START = Region.start("silk-release:references");
+	/**
+	* Closing marker of the closing-reference region.
+	*
+	* @public
+	*/
+	static REFERENCES_END = Region.end("silk-release:references");
+	/**
+	* The references opening marker up to its attributes, for locating a
+	* region whose `owned` list is unknown.
+	*
+	* @public
+	*/
+	static REFERENCES_START_PREFIX = "<!-- silk-release:references:start";
+	/**
+	* The fence language for the proposed squash-commit block.
+	*
+	* @remarks
+	* Not a GFM language and apparently undocumented, but GitHub renders it.
+	* It is a target for AI integrations to read and rewrite into the
+	* eventual squash-commit message. **Do not "correct" it to `text`.**
+	*
+	* @public
+	*/
+	static SQUASH_FENCE_LANGUAGE = "proposed-squash-commit";
+};
+
+//#endregion
+export { Markers };

package/pr-body/references.js

@@ -0,0 +1,159 @@
+import { Markers } from "./markers.js";
+import { LinkedIssueRef } from "./linked-issue.js";
+import { Schema } from "effect";
+
+//#region src/pr-body/references.ts
+/**
+* An ordered list of issue ids destined for closing references, with the two
+* renderers whose difference is the whole point of this module.
+*
+* @remarks
+* The same issues appear twice in a managed PR body, spelled differently, and
+* **neither consumer accepts the other's spelling**:
+*
+* - commitlint reads ONE comma-joined trailer (`Closes #1, #2`) inside the
+*   proposed-squash-commit fence — {@link ClosingReferences.renderTrailer};
+* - GitHub's linker reads one bare `Closes #N` line each, OUTSIDE every
+*   fence — {@link ClosingReferences.renderBareLines}. A reference inside a
+*   fenced block is inert to GitHub.
+*
+* The duplication is load-bearing. Never "simplify" a body by emitting one
+* form in both places: comma-joined bare lines link nothing (verified by hand
+* against live pull requests — `savvy-web/silk-integration` #242/#232 with no
+* bare line reported `closingIssuesReferences: []`, #243 with one reported
+* `[168]`), and per-line trailers inside the fence break the commit contract.
+*
+* Ids are stored exactly as given — construction neither deduplicates nor
+* sorts. Call {@link ClosingReferences.dedupe} where uniqueness is wanted;
+* the split exists because the squash trailer historically renders duplicates
+* as-given while the references region deduplicates, and byte-compatibility
+* with live PR bodies pins that behavior.
+*
+* @public
+*/
+var ClosingReferences = class ClosingReferences extends Schema.Class("ClosingReferences")({ ids: Schema.Array(Schema.Number.check(Schema.isInt())) }) {
+	/**
+	* A closing keyword and its issue reference, anchored per line.
+	*
+	* @remarks
+	* Anchored so a number mentioned in passing is not mistaken for a closing
+	* reference — matching what GitHub itself links on. Every keyword GitHub
+	* accepts is matched, not just the present-tense plural this contract
+	* emits: `close`/`closed`, `fix`/`fixed`, `resolve`/`resolved` and an
+	* optional colon are all valid, and a reference the parser fails to
+	* recognise is one the next regeneration silently deletes.
+	*/
+	static BARE_LINE_PATTERN = /^(?:close[sd]?|fix(?:e[sd])?|resolve[sd]?):?\s+#(\d+)$/i;
+	/**
+	* The open issues' ids, in input order, duplicates preserved.
+	*
+	* @remarks
+	* Closedness is decided by `LinkedIssueRef.isClosed` — the only
+	* sanctioned test, case-insensitive so REST (`closed`) and GraphQL
+	* (`CLOSED`) payloads classify identically.
+	*
+	* @public
+	*/
+	static fromIssues(issues) {
+		return ClosingReferences.make({ ids: issues.filter((issue) => !LinkedIssueRef.isClosed(issue)).map((issue) => issue.number) });
+	}
+	/**
+	* Issue ids carried by a region's bare closing lines.
+	*
+	* @public
+	*/
+	static parseBare(region) {
+		return region.split("\n").map((line) => ClosingReferences.BARE_LINE_PATTERN.exec(line.trim())?.[1]).filter((id) => id !== void 0).map(Number);
+	}
+	/**
+	* A copy with duplicate ids removed, first occurrence winning.
+	*
+	* @public
+	*/
+	dedupe() {
+		return ClosingReferences.make({ ids: [...new Set(this.ids)] });
+	}
+	/**
+	* The comma-joined trailer the squash-commit message carries, or `""`
+	* when there is nothing to close.
+	*
+	* @remarks
+	* `Closes #1, #2` on ONE line — the spelling commitlint reads and
+	* GitHub's linker ignores. See the class remarks before changing either
+	* renderer.
+	*
+	* @public
+	*/
+	renderTrailer() {
+		if (this.ids.length === 0) return "";
+		return `Closes ${this.ids.map((id) => `#${id}`).join(", ")}`;
+	}
+	/**
+	* One bare `Closes #N` line per id, or `""` when empty.
+	*
+	* @remarks
+	* The spelling GitHub's linker reads — each line must sit OUTSIDE every
+	* fenced block to link. See the class remarks before changing either
+	* renderer.
+	*
+	* @public
+	*/
+	renderBareLines() {
+		return this.ids.map((id) => `Closes #${id}`).join("\n");
+	}
+};
+/**
+* The `owned="…"` attribute on the references region's opening marker.
+*
+* @remarks
+* Records the issue ids a generating run emitted itself, so the next run can
+* tell its own references from ones an agent or human added. "Not in this
+* run's linked set" is NOT enough: a reference the previous run emitted also
+* disappears from the linked set when the release stops tracking that issue,
+* and treating it as agent-authored would preserve it forever — re-linking,
+* and on merge auto-closing, an issue the release deliberately dropped.
+*
+* **Never hand-edit the attribute.** A wrong value makes the next run delete
+* a real reference or resurrect a dropped one.
+*
+* @public
+*/
+var OwnedAttribute = class {
+	constructor() {}
+	/**
+	* The attribute as emitted on the opening marker.
+	*
+	* @public
+	*/
+	static render(ids) {
+		return `owned="${ids.join(",")}"`;
+	}
+	/**
+	* The ids the prior body's opening marker claims as the previous run's
+	* own.
+	*
+	* @remarks
+	* An absent or malformed attribute reads as "none", which degrades to
+	* treating every reference in the region as agent-authored. That
+	* preserves too much rather than deleting someone's work — the safe
+	* direction to fail. The match is anchored to an attribute boundary: an
+	* unanchored match also finds `data-owned="…"` and `unowned="…"`, which
+	* would let an unrelated attribute claim an agent's reference and get it
+	* dropped on the next run.
+	*
+	* @public
+	*/
+	static parse(priorBody) {
+		const from = priorBody.indexOf(Markers.REFERENCES_START_PREFIX);
+		if (from === -1) return /* @__PURE__ */ new Set();
+		const openEnd = priorBody.indexOf("-->", from);
+		if (openEnd === -1) return /* @__PURE__ */ new Set();
+		const attributes = priorBody.slice(from + Markers.REFERENCES_START_PREFIX.length, openEnd);
+		const owned = /(?:^|\s)owned="([\d,\s]*)"/.exec(attributes)?.[1];
+		if (owned === void 0) return /* @__PURE__ */ new Set();
+		return new Set(owned.split(",").map((part) => part.trim()).filter((part) => part !== "").map(Number));
+	}
+};
+
+//#endregion
+export { ClosingReferences, OwnedAttribute };