@savvy-web/silk-effects 5.7.2 → 5.8.1

package/index.d.ts

@@ -7346,11 +7346,11 @@ type TypeScriptCompiler = "tsgo" | "tsc";
 /**
  * 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.
  *
@@ -7386,10 +7386,16 @@ declare 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.
@@ -7411,7 +7417,7 @@ declare 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(): string;
@@ -8236,6 +8242,541 @@ declare namespace index_d_exports$2 {
   export { BaseHandlerOptions, Biome, BiomeOptions, Command, CreateConfigOptions, DEFAULT_CONFIG_PATH, Filter, HUSKY_HOOK_PATH, Handler, LegacySavvyLintHygieneDef, LintStagedConfig, LintStagedEntry, LintStagedHandler, MARKDOWNLINT_CONFIG, MARKDOWNLINT_CONFIG_PATH, MARKDOWNLINT_SCHEMA, MARKDOWNLINT_TEMPLATE, Markdown, MarkdownOptions, POST_CHECKOUT_HOOK_PATH, POST_COMMIT_HOOK_PATH, POST_MERGE_HOOK_PATH, PackageJson, PackageJsonOptions, PackageManager, PnpmWorkspace, PnpmWorkspaceContent, PnpmWorkspaceOptions, Preset, PresetExtendOptions, PresetType, SavvyLintSectionDef, ShellScripts, ShellScriptsOptions, ToolSearchResult, TypeScript, TypeScriptCompiler, TypeScriptOptions, WorkspacePackageInfo, Yaml, YamlOptions, createConfig, generateManagedContent, getWorkspacePackagePaths, getWorkspacePackages, getWorkspaceRoot, isWorkspacePackagePath, resetWorkspaceCache, savvyLintBlock };
 }
 //#endregion
+//#region src/pr-body/linked-issue.d.ts
+declare const LinkedIssueRef_base: Schema.Class<LinkedIssueRef, Schema.Struct<{
+  readonly number: Schema.Number;
+  readonly title: Schema.String;
+  readonly state: Schema.String;
+}>, {}>;
+/**
+ * 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
+ */
+declare class LinkedIssueRef extends LinkedIssueRef_base {
+  /**
+   * 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: {
+    readonly state: string;
+  }): boolean;
+}
+//#endregion
+//#region src/pr-body/body.d.ts
+/**
+ * The inputs to {@link ManagedPrBody.build}.
+ *
+ * @public
+ */
+interface ManagedPrBodyOptions {
+  /** The proposed squash-commit subject — a conventional-commit header. */
+  readonly subject: string;
+  /**
+   * Every issue this run knows about, open AND closed.
+   *
+   * @remarks
+   * The run decides every issue it knows about: an open issue is emitted, a
+   * closed one is dropped, and a carried line cannot resurrect one it
+   * deliberately dropped. Closedness is tested with
+   * `LinkedIssueRef.isClosed` (case-insensitive), so REST and GraphQL
+   * payloads both classify correctly.
+   */
+  readonly linkedIssues: ReadonlyArray<LinkedIssueRef>;
+  /** The DCO signoff line the squash-commit block carries. */
+  readonly signoff: string;
+  /**
+   * The summary region's current content, from
+   * {@link ManagedPrBody.extractSummary}.
+   *
+   * @remarks
+   * Passed in rather than read from `priorBody` so `build` stays explicit
+   * about it: the summary's owner decides what it says, and this function
+   * must not quietly overrule a caller that passed one. `""` reserves an
+   * empty region.
+   */
+  readonly summary: string;
+  /**
+   * The PR's previous description, verbatim.
+   *
+   * @remarks
+   * The WHOLE prior body rather than an extracted region: merging
+   * references needs both the region's lines and the `owned` attribute on
+   * its opening marker, and two separate parameters would eventually be
+   * passed inconsistently. Optional because a PR being created has no
+   * prior body.
+   */
+  readonly priorBody?: string;
+}
+/**
+ * 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
+ */
+declare class ManagedPrBody {
+  private 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: ManagedPrBodyOptions): string;
+  /**
+   * 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: string, managed: string): string;
+  /**
+   * 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: string): string;
+  /**
+   * 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: string): string;
+}
+//#endregion
+//#region src/pr-body/diagnostics.d.ts
+/**
+ * The problems {@link PrBodyDiagnostic.scan} can report about a body's
+ * markers.
+ *
+ * @public
+ */
+declare const PrBodyDiagnosticCode: Schema.Literals<readonly ["unpairedMarker", "duplicateMarker"]>;
+/**
+ * The problems {@link PrBodyDiagnostic.scan} can report about a body's
+ * markers.
+ *
+ * @public
+ */
+type PrBodyDiagnosticCode = typeof PrBodyDiagnosticCode.Type;
+declare const PrBodyDiagnostic_base: Schema.Class<PrBodyDiagnostic, Schema.Struct<{
+  readonly code: Schema.Literals<readonly ["unpairedMarker", "duplicateMarker"]>;
+  /** The region token the problem is about, e.g. `silk-release:summary`. */
+  readonly token: Schema.String;
+}>, {}>;
+/**
+ * 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
+ */
+declare class PrBodyDiagnostic extends PrBodyDiagnostic_base {
+  /**
+   * A human-readable description, derived from the structured fields.
+   *
+   * @public
+   */
+  get message(): string;
+  /**
+   * 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: string): ReadonlyArray<PrBodyDiagnostic>;
+}
+//#endregion
+//#region src/pr-body/markers.d.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
+ */
+declare class Markers {
+  private 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 readonly MANAGED_START: string;
+  /**
+   * Closing marker of the whole managed region.
+   *
+   * @public
+   */
+  static readonly MANAGED_END: string;
+  /**
+   * 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 readonly SUMMARY_START: string;
+  /**
+   * Closing marker of the summariser's region.
+   *
+   * @public
+   */
+  static readonly SUMMARY_END: string;
+  /**
+   * 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 readonly REFERENCES_START: string;
+  /**
+   * Closing marker of the closing-reference region.
+   *
+   * @public
+   */
+  static readonly REFERENCES_END: string;
+  /**
+   * The references opening marker up to its attributes, for locating a
+   * region whose `owned` list is unknown.
+   *
+   * @public
+   */
+  static readonly 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 readonly SQUASH_FENCE_LANGUAGE = "proposed-squash-commit";
+}
+//#endregion
+//#region src/pr-body/references.d.ts
+declare const ClosingReferences_base: Schema.Class<ClosingReferences, Schema.Struct<{
+  readonly ids: Schema.$Array<Schema.Number>;
+}>, {}>;
+/**
+ * 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
+ */
+declare class ClosingReferences extends ClosingReferences_base {
+  /**
+   * 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 readonly BARE_LINE_PATTERN: RegExp;
+  /**
+   * 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: ReadonlyArray<LinkedIssueRef>): ClosingReferences;
+  /**
+   * Issue ids carried by a region's bare closing lines.
+   *
+   * @public
+   */
+  static parseBare(region: string): ReadonlyArray<number>;
+  /**
+   * A copy with duplicate ids removed, first occurrence winning.
+   *
+   * @public
+   */
+  dedupe(): ClosingReferences;
+  /**
+   * 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(): string;
+  /**
+   * 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(): string;
+}
+/**
+ * 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
+ */
+declare class OwnedAttribute {
+  private constructor();
+  /**
+   * The attribute as emitted on the opening marker.
+   *
+   * @public
+   */
+  static render(ids: ReadonlyArray<number>): string;
+  /**
+   * 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: string): ReadonlySet<number>;
+}
+//#endregion
+//#region src/pr-body/region.d.ts
+/**
+ * The generic marker-delimited region grammar every silk-managed document
+ * uses: `<!-- token:start -->` … `<!-- token:end -->`.
+ *
+ * @remarks
+ * Extracted from `silk-release-action` (its `pr-body.ts` and
+ * `managed-sections.ts` both carried a private copy) so the grammar has one
+ * owner. **Every marker is a pair.** A lone opening marker can only be located
+ * by scanning forward to whatever happens to follow it, which makes the
+ * region's extent a function of its neighbours rather than of itself — moving
+ * anything nearby silently redefines it. The token is free-form; `:start` and
+ * `:end` are the whole contract, so pairs nest and a region can contain
+ * sub-regions without either needing to know about the other.
+ */
+/**
+ * Pure helpers over the `<!-- token:start -->` / `<!-- token:end -->` region
+ * grammar.
+ *
+ * @remarks
+ * Every operation is total: a body with no region (or a broken pair) degrades
+ * to the documented fail-safe result rather than failing, because the callers
+ * are regenerating actions that must still produce a body when the prior one
+ * is malformed. Use `PrBodyDiagnostic.scan` when a caller wants to be told
+ * about a broken pair instead of silently tolerating it.
+ *
+ * @public
+ */
+declare class Region {
+  private constructor();
+  /**
+   * The opening delimiter for a named region.
+   *
+   * @public
+   */
+  static start(token: string): string;
+  /**
+   * The closing delimiter for a named region.
+   *
+   * @public
+   */
+  static end(token: string): string;
+  /**
+   * The content between a region's delimiters, or `undefined` when absent.
+   *
+   * @remarks
+   * Finds the FIRST opening marker and the matching close after it, so a
+   * nested region of a different token is returned as part of the content
+   * rather than truncating it.
+   *
+   * @public
+   */
+  static read(body: string, token: string): string | undefined;
+  /**
+   * Everything outside a region, with the region and its delimiters removed.
+   *
+   * @remarks
+   * A body without the region comes back unchanged — removal of an absent
+   * region is a no-op, not an error.
+   *
+   * @public
+   */
+  static strip(body: string, token: string): string;
+  /**
+   * Put `rendered` (a fully rendered region, its own markers included) into
+   * `body`, replacing a previous region of the same token and leaving
+   * everything else alone.
+   *
+   * @remarks
+   * **Human edits outside the markers survive.** A predecessor spliced on a
+   * markdown heading, which silently ate any content a human happened to put
+   * under a heading of that name and could not tell generated text from
+   * theirs. An explicit marker pair can.
+   *
+   * A body with no markers keeps its content and gains the region **below**
+   * it, so an existing hand-written document is not displaced. The result is
+   * trimmed.
+   *
+   * @public
+   */
+  static upsert(body: string, token: string, rendered: string): string;
+}
+declare namespace index_d_exports$3 {
+  export { ClosingReferences, LinkedIssueRef, ManagedPrBody, ManagedPrBodyOptions, Markers, OwnedAttribute, PrBodyDiagnostic, PrBodyDiagnosticCode, Region };
+}
+//#endregion
 //#region src/repos/constants.d.ts
 /**
  * Directory vendored reference repos live under, relative to the repo root.
@@ -8908,7 +9449,7 @@ declare class ReposManager extends ReposManager_base {
    */
   static readonly layer: Layer.Layer<ReposManager, never, ReposConfigStore | Git | FileSystem.FileSystem | Path.Path | ReposLockdown>;
 }
-declare namespace index_d_exports$3 {
+declare namespace index_d_exports$4 {
   export { DriftKind, GitSubmoduleError, GitSubmoduleErrorBase, MANIFEST_PATH, NOTE_LIMIT, NoteNotFoundError, NoteNotFoundErrorBase, REPOS_DIR, RepoDrift, RepoEntry, RepoName, RepoNotFoundError, RepoNotFoundErrorBase, RepoNote, RepoOrientation, RepoStatusEntry, ReposAddResult, ReposConfigError, ReposConfigErrorBase, ReposConfigStore, ReposConfigStoreShape, ReposDrift, ReposDriftReport, ReposDriftShape, ReposLockdown, ReposLockdownError, ReposLockdownErrorBase, ReposLockdownShape, ReposManager, ReposManagerShape, ReposManifestFile, ReposNoteResult, ReposPinResult, ReposRemoveResult, ReposRenameResult, ReposRestoreResult, ReposStatusReport, ReposSyncReport, STALE_LOCK_MAX_AGE_MS, resolveModuleDir };
 }
 //#endregion
@@ -10023,9 +10564,9 @@ declare class TurboInspector extends TurboInspector_base {
    */
   static readonly layer: Layer.Layer<TurboInspector, never, ToolDiscovery | ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | Git>;
 }
-declare namespace index_d_exports$4 {
+declare namespace index_d_exports$5 {
   export { AffectedResult, AffectedResultType, CacheDiagnosis, CacheDiagnosisType, DryRunParseError, GlobalHashSummary, GraphNode, MissExplanation, NotATurboRepoError, PackageCacheStatus, TaskGraphResult, TaskGraphResultType, TurboCache, TurboDigest, TurboDryRun, TurboDryRunType, TurboDryTask, TurboDryTaskType, TurboEnvVars, TurboError, TurboExecError, TurboGlobalCacheInputs, TurboInspector, TurboInspectorShape, TurboNotInstalledError };
 }
 //#endregion
-export { AnalyzedWorkspace, BiomeSchemaSync, type BiomeSchemaSyncShape, BiomeSyncError, type BiomeSyncOptions, type BiomeSyncResult, ChangesetConfig, ChangesetConfigError, type ChangesetConfigFile, ChangesetConfigReader, type ChangesetConfigReaderShape, type ChangesetConfigShape, type ChangesetMode, index_d_exports as Changesets, index_d_exports$1 as Commitlint, type CommitlintPlugin, type CommitlintUserConfig, ConfigDiscovery, type ConfigDiscoveryOptions, type ConfigDiscoveryShape, type ConfigLocation, ConfigNotFoundError, type ConfigSource, index_d_exports$2 as Lint, type PromptConfig, type PromptSettings, PublishTargetBindingError, type PublishablePackage, type RawPackageJson, type RawPublishConfig, type RawPublishTargets, type RawTargetObject, type RawTargetValue, index_d_exports$3 as Repos, type RuleApplicability, type RuleConfigTuple, type RuleSeverity, type RulesConfig, SavvyBaseSection, SavvyHooksSection, type SilkChangesetConfigFile, SilkPublishConfig, SilkPublishability, SilkWorkspaceAnalyzer, type SilkWorkspaceAnalyzerShape, type TargetBinding, type TargetGroupBinding, type TargetsBinding, index_d_exports$4 as Turbo, WorkspaceAnalysis, WorkspaceAnalysisError, buildSchemaUrl, extractSemver, readTargetsBinding, savvyBasePreamble, savvyHooksHygiene, savvyToolSection };
+export { AnalyzedWorkspace, BiomeSchemaSync, type BiomeSchemaSyncShape, BiomeSyncError, type BiomeSyncOptions, type BiomeSyncResult, ChangesetConfig, ChangesetConfigError, type ChangesetConfigFile, ChangesetConfigReader, type ChangesetConfigReaderShape, type ChangesetConfigShape, type ChangesetMode, index_d_exports as Changesets, index_d_exports$1 as Commitlint, type CommitlintPlugin, type CommitlintUserConfig, ConfigDiscovery, type ConfigDiscoveryOptions, type ConfigDiscoveryShape, type ConfigLocation, ConfigNotFoundError, type ConfigSource, index_d_exports$2 as Lint, index_d_exports$3 as PrBody, type PromptConfig, type PromptSettings, PublishTargetBindingError, type PublishablePackage, type RawPackageJson, type RawPublishConfig, type RawPublishTargets, type RawTargetObject, type RawTargetValue, index_d_exports$4 as Repos, type RuleApplicability, type RuleConfigTuple, type RuleSeverity, type RulesConfig, SavvyBaseSection, SavvyHooksSection, type SilkChangesetConfigFile, SilkPublishConfig, SilkPublishability, SilkWorkspaceAnalyzer, type SilkWorkspaceAnalyzerShape, type TargetBinding, type TargetGroupBinding, type TargetsBinding, index_d_exports$5 as Turbo, WorkspaceAnalysis, WorkspaceAnalysisError, buildSchemaUrl, extractSemver, readTargetsBinding, savvyBasePreamble, savvyHooksHygiene, savvyToolSection };
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -10,6 +10,7 @@ import { ConfigNotFoundError } from "./errors/ConfigNotFoundError.js";
 import { WorkspaceAnalysisError } from "./errors/WorkspaceAnalysisError.js";
 import { SavvyBaseSection, SavvyHooksSection, savvyBasePreamble, savvyHooksHygiene, savvyToolSection } from "./schemas/SavvySections.js";
 import { lint_exports } from "./lint/index.js";
+import { pr_body_exports } from "./pr-body/index.js";
 import { repos_exports } from "./repos/index.js";
 import { AnalyzedWorkspace, SilkPublishConfig, WorkspaceAnalysis } from "./schemas/WorkspaceAnalysisSchemas.js";
 import { BiomeSchemaSync, buildSchemaUrl, extractSemver } from "./services/BiomeSchemaSync.js";
@@ -17,4 +18,4 @@ import { ConfigDiscovery } from "./services/ConfigDiscovery.js";
 import { SilkWorkspaceAnalyzer } from "./services/SilkWorkspaceAnalyzer.js";
 import { turbo_exports } from "./turbo/index.js";
 
-export { AnalyzedWorkspace, BiomeSchemaSync, BiomeSyncError, ChangesetConfig, ChangesetConfigError, ChangesetConfigReader, changesets_exports as Changesets, commitlint_exports as Commitlint, ConfigDiscovery, ConfigNotFoundError, lint_exports as Lint, PublishTargetBindingError, repos_exports as Repos, SavvyBaseSection, SavvyHooksSection, SilkPublishConfig, SilkPublishability, SilkWorkspaceAnalyzer, turbo_exports as Turbo, WorkspaceAnalysis, WorkspaceAnalysisError, buildSchemaUrl, extractSemver, readTargetsBinding, savvyBasePreamble, savvyHooksHygiene, savvyToolSection };
+export { AnalyzedWorkspace, BiomeSchemaSync, BiomeSyncError, ChangesetConfig, ChangesetConfigError, ChangesetConfigReader, changesets_exports as Changesets, commitlint_exports as Commitlint, ConfigDiscovery, ConfigNotFoundError, lint_exports as Lint, pr_body_exports as PrBody, PublishTargetBindingError, repos_exports as Repos, SavvyBaseSection, SavvyHooksSection, SilkPublishConfig, SilkPublishability, SilkWorkspaceAnalyzer, turbo_exports as Turbo, WorkspaceAnalysis, WorkspaceAnalysisError, buildSchemaUrl, extractSemver, readTargetsBinding, savvyBasePreamble, savvyHooksHygiene, savvyToolSection };