@savvy-web/silk-core 0.1.0

package/index.d.ts

@@ -0,0 +1,1261 @@
+import { Equal, Hash, Option, Schema } from "effect";
+import { Section, SectionId } from "@effected/templates";
+import { PublishConfig, PublishTarget, VersioningStrategy } from "@effected/workspaces";
+//#endregion
+//#region src/errors/BiomeSyncError.d.ts
+declare const BiomeSyncError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "BiomeSyncError";
+} & Readonly<A>;
+/**
+ * Raised when a Biome config file cannot be read or its `$schema` URL cannot be updated.
+ *
+ * @remarks
+ * Returned by `BiomeSchemaSync.sync` and `BiomeSchemaSync.check` when
+ * a `biome.json` or `biome.jsonc` file exists but cannot be read, contains invalid JSON,
+ * or cannot be written back to disk.
+ *
+ * @since 0.1.0
+ * @public
+ */
+export declare class BiomeSyncError extends BiomeSyncError_base<{
+  readonly path: string;
+  readonly reason: string;
+}> {
+  get message(): string;
+}
+//#endregion
+//#region src/errors/ChangesetConfigError.d.ts
+declare const ChangesetConfigError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "ChangesetConfigError";
+} & Readonly<A>;
+/**
+ * Raised when the `.changeset/config.json` file cannot be read or decoded.
+ *
+ * @remarks
+ * Returned by `ChangesetConfigReader.read` when the file is missing,
+ * contains invalid JSON, or fails Effect Schema validation.
+ *
+ * @since 0.1.0
+ * @public
+ */
+export declare class ChangesetConfigError extends ChangesetConfigError_base<{
+  readonly path: string;
+  readonly reason: string;
+}> {
+  get message(): string;
+}
+//#endregion
+//#region src/errors/ConfigNotFoundError.d.ts
+declare const ConfigNotFoundError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "ConfigNotFoundError";
+} & Readonly<A>;
+/**
+ * Raised when a config file cannot be located in any of the expected locations.
+ *
+ * @remarks
+ * Returned by consumers that require a config file to exist. `ConfigDiscovery.find`
+ * itself returns `null` instead of failing — callers that need a hard failure should
+ * map `null` to this error.
+ *
+ * @since 0.1.0
+ * @public
+ */
+export declare class ConfigNotFoundError extends ConfigNotFoundError_base<{
+  readonly name: string;
+  readonly searchedPaths: ReadonlyArray<string>;
+}> {
+  get message(): string;
+}
+//#endregion
+//#region src/errors/PublishTargetBindingError.d.ts
+declare const PublishTargetBindingError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "PublishTargetBindingError";
+} & Readonly<A>;
+/**
+ * Raised when publishability detection selects a directory that the package's
+ * `dist/prod/targets.json` binding does not describe.
+ *
+ * @remarks
+ * The bundler's prod build writes `targets.json` naming every byte-group
+ * directory it produced. Once that binding exists it is authoritative: the only
+ * directories whose bytes may be published are the ones it lists. A detector
+ * that returns anything else — most often `publishConfig.directory` pointing at
+ * a **dev** build, because silk mode was misdetected — is about to pack an
+ * unresolved workspace manifest and ship it to a registry.
+ *
+ * That is the `yaml-effect@0.7.1` failure: detection picked `dist/dev/pkg`, the
+ * dev manifest still carried `catalog:` specifiers, and the published package
+ * was uninstallable (`EUNSUPPORTEDPROTOCOL`).
+ *
+ * @since 3.1.0
+ * @public
+ */
+export declare class PublishTargetBindingError extends PublishTargetBindingError_base<{
+  /** The package whose targets were being resolved. */
+  readonly pkg: string;
+  /** The directory detection selected, relative to the package root. */
+  readonly directory: string;
+  /** The group directories the prod binding actually describes. */
+  readonly boundDirectories: ReadonlyArray<string>;
+}> {
+  get message(): string;
+}
+//#endregion
+//#region src/errors/WorkspaceAnalysisError.d.ts
+declare const WorkspaceAnalysisError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "WorkspaceAnalysisError";
+} & Readonly<A>;
+/**
+ * Raised when workspace analysis fails for a given root directory.
+ *
+ * @remarks
+ * Returned by `SilkWorkspaceAnalyzer.analyze` when the analysis pipeline
+ * encounters an unrecoverable error — e.g. workspace discovery failure,
+ * package manager detection failure, or publishability detection errors.
+ *
+ * @since 0.2.0
+ * @public
+ */
+export declare class WorkspaceAnalysisError extends WorkspaceAnalysisError_base<{
+  readonly root: string;
+  readonly reason: string;
+}> {
+  get message(): string;
+}
+//#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 {
+  /**
+   * 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.
+   *
+   * @remarks
+   * The region is read with `@effected/github-references`' `parseBareLines`
+   * — per line, the whole line, after trimming, must be
+   * `<keyword>[:] #<number>`, so a number mentioned in passing is never
+   * mistaken for a closing reference. Every keyword GitHub accepts counts,
+   * not just the present-tense plural this contract emits, because a
+   * reference the parser fails to recognise is one the next regeneration
+   * silently deletes.
+   *
+   * @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 {
+  export { ClosingReferences, LinkedIssueRef, ManagedPrBody, ManagedPrBodyOptions, Markers, OwnedAttribute, PrBodyDiagnostic, PrBodyDiagnosticCode, Region };
+}
+//#endregion
+//#region src/schemas/BiomeConfig.d.ts
+/**
+ * Result of a Biome schema URL sync or check operation.
+ *
+ * @remarks
+ * - `updated` — paths of config files whose `$schema` URL was changed (or would be changed on `check`).
+ * - `skipped` — paths of config files with no `$schema` field or a non-biomejs.dev URL.
+ * - `current` — paths of config files already pointing to the expected schema URL.
+ *
+ * @since 0.1.0
+ * @public
+ */
+export declare const BiomeSyncResult: Schema.Struct<{
+  readonly updated: Schema.$Array<Schema.String>;
+  readonly skipped: Schema.$Array<Schema.String>;
+  readonly current: Schema.$Array<Schema.String>;
+}>;
+/**
+ * @since 0.1.0
+ * @public
+ */
+export type BiomeSyncResult = typeof BiomeSyncResult.Type;
+/**
+ * Options for `BiomeSchemaSync` operations.
+ *
+ * @remarks
+ * `cwd` overrides the working directory used to locate `biome.json` / `biome.jsonc`.
+ * `gitignore` is reserved for future use to skip gitignored config files (defaults to `true`).
+ *
+ * @since 0.1.0
+ * @public
+ */
+export declare const BiomeSyncOptions: Schema.Struct<{
+  readonly cwd: Schema.optional<Schema.String>;
+  readonly gitignore: Schema.withConstructorDefault<Schema.withDecodingDefaultType<Schema.Boolean, never>>;
+}>;
+/**
+ * @since 0.1.0
+ * @public
+ */
+export type BiomeSyncOptions = typeof BiomeSyncOptions.Type;
+//#endregion
+//#region src/schemas/ConfigDiscoverySchemas.d.ts
+/**
+ * The discovery strategy used to locate a config file.
+ *
+ * @remarks
+ * - `"lib"` — found under `lib/configs/{name}` relative to the workspace root.
+ * - `"root"` — found directly in the workspace root as `{name}`.
+ * - `"cosmiconfig"` — reserved for future cosmiconfig-based discovery.
+ *
+ * @since 0.1.0
+ * @public
+ */
+export declare const ConfigSource: Schema.Literals<readonly ["lib", "root", "cosmiconfig"]>;
+/**
+ * @since 0.1.0
+ * @public
+ */
+export type ConfigSource = typeof ConfigSource.Type;
+/**
+ * The resolved location of a discovered config file.
+ *
+ * @remarks
+ * Produced by `ConfigDiscovery.find` and `ConfigDiscovery.findAll`.
+ * `path` is the absolute file path; `source` indicates how it was discovered.
+ *
+ * @since 0.1.0
+ * @public
+ */
+export declare const ConfigLocation: Schema.Struct<{
+  readonly path: Schema.String;
+  readonly source: Schema.Literals<readonly ["lib", "root", "cosmiconfig"]>;
+}>;
+/**
+ * @since 0.1.0
+ * @public
+ */
+export type ConfigLocation = typeof ConfigLocation.Type;
+/**
+ * Options passed to config discovery methods.
+ *
+ * @remarks
+ * `cwd` overrides the working directory for path resolution (defaults to the current working directory).
+ * `tool` is reserved for future use as a tool-specific discovery hint.
+ *
+ * @since 0.1.0
+ * @public
+ */
+export declare const ConfigDiscoveryOptions: Schema.Struct<{
+  readonly cwd: Schema.optional<Schema.String>;
+  readonly tool: Schema.optional<Schema.String>;
+}>;
+/**
+ * @since 0.1.0
+ * @public
+ */
+export type ConfigDiscoveryOptions = typeof ConfigDiscoveryOptions.Type;
+//#endregion
+//#region src/schemas/SavvyInstallSection.d.ts
+/**
+ * The hooks {@link savvyInstallDeps} can be generated for.
+ *
+ * @remarks
+ * Both are needed, and `post-merge` is the one that matters most in practice:
+ * a fast-forward `git pull` — the batch-alignment case this exists for — fires
+ * `post-merge` and never `post-checkout`. They are separate spellings rather
+ * than one argument-sniffing block because the two hooks disagree on both
+ * halves of the decision: `post-checkout` is handed `<prev> <new> <flag>` and
+ * must ignore a file checkout, while `post-merge` is handed only a squash flag
+ * and has to recover its own range from `ORIG_HEAD`.
+ *
+ * @since 7.5.0
+ * @public
+ */
+type SavvyInstallHook = "post-checkout" | "post-merge";
+/**
+ * Section identity for the dependency auto-install block.
+ *
+ * `toolName` is `"savvy-install"`; pair with {@link savvyInstallDeps}.
+ *
+ * @since 7.5.0
+ * @public
+ */
+export declare const SavvyInstallSection: SectionId;
+/**
+ * Dependency auto-install shared across Silk Suite hook files.
+ *
+ * @remarks
+ * Brings `node_modules` back in line after a branch switch or a pull, so a batch
+ * of repos pulled to align their dependencies does not each need a manual
+ * install. Installs with lifecycle scripts skipped — `--ignore-scripts`, or
+ * `--mode=skip-build` for Yarn Berry, which dropped the former — because the goal
+ * is to get the dependency tree on disk, not to run a full postinstall.
+ *
+ * **That flag has a cost, and one shape of repo cannot pay it.** Where a package
+ * publishes through a built link directory — `publishConfig.directory` with
+ * `linkDirectory: true`, which is how this monorepo wires `dist/dev/pkg` — the
+ * workspace resolves its own dependencies through a directory that a `prepare`
+ * script has to build, and skipping scripts yields a populated `node_modules`
+ * pointing at nothing.
+ *
+ * Those repos ask for a full install through the LOCAL git config key
+ * `savvy.installLifecycleScripts`, which `savvy init` sets when it finds the
+ * shape. The decision deliberately does NOT read the checked-out tree. Doing so
+ * failed in both directions at once: a branch that merely declared the shape
+ * could turn lifecycle scripts back on just by being checked out, making
+ * `git checkout` of an untrusted revision a code-execution path; and the `jq`
+ * the scan needed is absent on stock macOS and Ubuntu, where the missing answer
+ * silently skipped scripts in precisely the repos that cannot survive it.
+ * `.git/config` is neither checked out nor parsed with `jq`, so it has neither
+ * failure mode.
+ *
+ * The package managers gate dependency scripts themselves on top of this —
+ * pnpm's `strictDepBuilds` with an `allowBuilds` allowlist being the case in
+ * point — but workspace and root lifecycle scripts still run, which is why the
+ * opt-in is local rather than inferred. With the flag on, the hook says on the
+ * way out that scripts were skipped rather than leaving it to be discovered.
+ *
+ * Deliberately self-contained, like `savvyToolchainCheck`: its homes carry
+ * `SavvyHooksSection` but no `SavvyBaseSection`, so it defines its own root, CI
+ * and package-manager lookups rather than depending on `ROOT`, `in_ci` or `PM`.
+ *
+ * Four guards keep it from firing on the many checkouts that are not dependency
+ * events, each a silent no-op:
+ *
+ * - CI, where the runtime action owns installation by construction.
+ * - `SAVVY_SKIP_INSTALL`, the escape hatch for a bisect or a scripted sweep that
+ *   does not want an install between steps.
+ * - `post-checkout` only: a branch-flag of `0`, which is `git checkout -- <file>`
+ *   and not a move between commits.
+ * - **The gate that makes this affordable:** nothing dependency-related actually
+ *   changed across the move. Without it every branch switch would pay for a full
+ *   install. A missing `node_modules` overrides it, since there is nothing to be
+ *   stale.
+ *
+ * A fresh clone is not among the cases it handles, and cannot be: husky sets
+ * `core.hooksPath` from its own `prepare` script, so until the first manual
+ * install has run there is no hook installed to fire.
+ *
+ * The install's exit status is swallowed and its output goes to stderr. Git
+ * ignores what `post-checkout` and `post-merge` return, so a failure here must
+ * not look like a failed checkout; the hint names the escape hatch instead.
+ *
+ * Every probe that can legitimately fail — no `ORIG_HEAD` to compare against, an
+ * unresolvable range — is neutralised with `|| true` rather than left to its own
+ * status. These blocks are co-owned and consumer content can sit below them, so
+ * under a hook running `set -e` a bare failing substitution would abort the whole
+ * file and take those later sections with it.
+ *
+ * @param hook - Which hook the block is being generated for; decides the
+ *   argument guard and how the comparison range is recovered.
+ * @returns The install shell, with no surrounding markers or trailing newline.
+ *
+ * @since 7.5.0
+ * @public
+ */
+export declare function savvyInstallDeps(hook: SavvyInstallHook): string;
+/**
+ * The local git config key that authorizes lifecycle scripts during a hook install.
+ *
+ * @remarks
+ * Local scope only. It lives in `.git/config`, which is never checked out, so no
+ * incoming revision can set it — that is the whole point of reading the decision
+ * from here rather than from a manifest in the tree.
+ *
+ * @since 7.5.0
+ * @public
+ */
+export declare const LIFECYCLE_SCRIPTS_CONFIG_KEY = "savvy.installLifecycleScripts";
+/**
+ * Whether `manifest` publishes through a built link directory.
+ *
+ * @remarks
+ * `publishConfig.directory` with `linkDirectory: true` means consumers of this
+ * package resolve it through a directory that a `prepare` script has to produce,
+ * so an install that skips lifecycle scripts leaves the link pointing at nothing.
+ * A workspace containing any such package is one whose owner probably wants
+ * {@link LIFECYCLE_SCRIPTS_CONFIG_KEY} set.
+ *
+ * Reporting the shape is deliberately separate from acting on it: this answers
+ * "does this repo need scripts", and a human still decides whether hook-time
+ * installs may run them.
+ *
+ * @param manifest - A parsed `package.json`; any non-object reads as `false`.
+ *
+ * @since 7.5.0
+ * @public
+ */
+export declare function publishesBuiltLinkDirectory(manifest: unknown): boolean;
+/**
+ * Build the dependency auto-install block for `hook`.
+ *
+ * @param hook - Which hook the section is destined for.
+ * @returns A shell `Section` (`commentStyle: hash`) keyed `SAVVY-INSTALL`.
+ *
+ * @since 7.5.0
+ * @public
+ */
+export declare function savvyInstallBlock(hook: SavvyInstallHook): Section;
+//#endregion
+//#region src/schemas/SavvySections.d.ts
+/**
+ * Section identity for the shared package-manager preamble.
+ *
+ * `toolName` is `"savvy-base"`; pair with {@link savvyBasePreamble} to build the block:
+ *
+ * @example
+ * ```ts
+ * const section = SavvyBaseSection.section(savvyBasePreamble());
+ * ```
+ *
+ * @since 0.5.0
+ * @public
+ */
+export declare const SavvyBaseSection: SectionId;
+/**
+ * Section identity for the shared repo-hygiene block.
+ *
+ * `toolName` is `"savvy-hooks"`; pair with {@link savvyHooksHygiene}.
+ *
+ * @since 0.5.0
+ * @public
+ */
+export declare const SavvyHooksSection: SectionId;
+/**
+ * Package-manager detection preamble shared across Silk Suite hook files.
+ *
+ * @remarks
+ * Side-effect-free definitions meant to run unconditionally — no markers, no outer CI
+ * guard. Defines `ROOT`, the `in_ci` predicate, `PM` (via `detect_pm`), and `pm_exec`.
+ * `pm_exec` uses local/exec semantics for every package manager and `bun x` (space form),
+ * which works regardless of how bun was installed (the `bunx` shim is not always on PATH).
+ *
+ * @returns The preamble shell, with no surrounding markers or trailing newline.
+ *
+ * @since 0.5.0
+ * @public
+ */
+export declare function savvyBasePreamble(): string;
+/**
+ * Repo-hygiene block shared across Silk Suite hook files.
+ *
+ * @remarks
+ * Self-guarded against CI and needs no package manager: disables Git's `core.fileMode`
+ * tracking and marks tracked shell scripts executable.
+ *
+ * @returns The hygiene shell, with no surrounding markers or trailing newline.
+ *
+ * @since 0.5.0
+ * @public
+ */
+export declare function savvyHooksHygiene(): string;
+/**
+ * Build a consumer's one-line tool section so every consumer calls the shared base
+ * helpers identically.
+ *
+ * @remarks
+ * The returned block's content is exactly `in_ci || pm_exec <command>` with `command`
+ * appended verbatim — it is not parsed, quoted, or interpolated, so shell tokens like
+ * `$ROOT` and `$1` survive into the generated literal.
+ *
+ * **Precondition:** a {@link SavvyBaseSection} block must precede this section in the same
+ * hook file so `in_ci` and `pm_exec` are defined. Consumers guarantee this by passing both
+ * to `ManagedSection.syncAll` in order:
+ *
+ * @example
+ * ```ts
+ * yield* sections.syncAll(".husky/commit-msg", [
+ *   SavvyBaseSection.section(savvyBasePreamble()),
+ *   savvyToolSection("savvy-commit", 'commitlint --config "$ROOT/lib/configs/commitlint.config.ts" --edit "$1"'),
+ * ]);
+ * ```
+ *
+ * @param toolName - Section identity; also drives the marker names (uppercased).
+ * @param command - The command passed verbatim to `pm_exec`, run only outside CI.
+ * @returns A shell `Section` (`commentStyle: hash`) for `toolName`.
+ *
+ * @since 0.5.0
+ * @public
+ */
+export declare function savvyToolSection(toolName: string, command: string): Section;
+/**
+ * Section identity for the package-manager toolchain drift check.
+ *
+ * `toolName` is `"savvy-toolchain"`; pair with {@link savvyToolchainCheck}.
+ *
+ * @since 7.3.0
+ * @public
+ */
+export declare const SavvyToolchainSection: SectionId;
+/**
+ * Package-manager drift check shared across Silk Suite hook files.
+ *
+ * @remarks
+ * Compares the running package manager's version against the repo's
+ * `devEngines.packageManager` pin and prints a warning on mismatch. **Warn only** —
+ * it never blocks the hook and never installs anything, so nobody mid-bisect or
+ * mid-rebase on an older pin is stranded.
+ *
+ * Deliberately self-contained: its homes are `.husky/post-checkout` and
+ * `.husky/post-merge`, which carry {@link SavvyHooksSection} but no
+ * {@link SavvyBaseSection}, so it defines its own root/CI/pin lookups rather than
+ * depending on `ROOT`, `in_ci` or `PM`. It honours the `name` recorded in the pin
+ * rather than assuming pnpm.
+ *
+ * Every input is treated as optional: no `git` root, no `jq`, no `devEngines` block,
+ * or a package manager that is not on `PATH` all mean "say nothing". Only an exact
+ * pin is comparable, so ranges (`^1.2.3`, `>=1 || <2`) and wildcards (`1.x`) are
+ * skipped, and the `+sha512…` integrity tail `devEngines` versions routinely carry is
+ * stripped before comparison. Skipped under CI, where the runtime action installs the
+ * pin by construction.
+ *
+ * @returns The drift-check shell, with no surrounding markers or trailing newline.
+ *
+ * @since 7.3.0
+ * @public
+ */
+export declare function savvyToolchainCheck(): string;
+//#endregion
+//#region src/schemas/VersioningSchemas.d.ts
+/**
+ * Standard changesets configuration matching the `@changesets/config@4.0.0` spec.
+ *
+ * @remarks
+ * Represents the parsed `.changeset/config.json` file. All fields are optional
+ * to allow partial configs. Use {@link (SilkChangesetConfigFile:type)} when the Silk changelog
+ * adapter is detected.
+ *
+ * @since 0.1.0
+ */
+/** @public */
+export declare const ChangesetConfigFile: Schema.Struct<{
+  readonly changelog: Schema.optional<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.Unknown>, Schema.Literal<false>]>>;
+  readonly commit: Schema.optional<Schema.Union<readonly [Schema.Boolean, Schema.String, Schema.$Array<Schema.Unknown>]>>;
+  readonly fixed: Schema.optional<Schema.$Array<Schema.$Array<Schema.String>>>;
+  readonly linked: Schema.optional<Schema.$Array<Schema.$Array<Schema.String>>>;
+  readonly access: Schema.optional<Schema.Literals<readonly ["public", "restricted"]>>;
+  readonly baseBranch: Schema.optional<Schema.String>;
+  readonly updateInternalDependencies: Schema.optional<Schema.Literals<readonly ["patch", "minor", "major"]>>;
+  readonly ignore: Schema.optional<Schema.$Array<Schema.String>>;
+  readonly privatePackages: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+    readonly tag: Schema.optional<Schema.Boolean>;
+    readonly version: Schema.optional<Schema.Boolean>;
+  }>, Schema.Literal<false>]>>;
+  readonly prettier: Schema.optional<Schema.Boolean>;
+  readonly changedFilePatterns: Schema.optional<Schema.$Array<Schema.String>>;
+  readonly bumpVersionsWithWorkspaceProtocolOnly: Schema.optional<Schema.Boolean>;
+  readonly snapshot: Schema.optional<Schema.Struct<{
+    readonly useCalculatedVersion: Schema.optional<Schema.Boolean>;
+    readonly prereleaseTemplate: Schema.optional<Schema.String>;
+  }>>;
+}>;
+/**
+ * @since 0.1.0
+ * @public
+ */
+export type ChangesetConfigFile = typeof ChangesetConfigFile.Type;
+/**
+ * Extended changeset config for repos using the `@savvy-web/changesets` changelog adapter.
+ *
+ * @remarks
+ * Extends {@link (ChangesetConfigFile:type)} with a `_isSilk` marker flag that is automatically
+ * set to `true`. Detected by `ChangesetConfigReader` when the `changelog` field
+ * references `@savvy-web/changesets`.
+ *
+ * @since 0.1.0
+ */
+/** @public */
+export declare const SilkChangesetConfigFile: Schema.Struct<{
+  readonly changelog: Schema.optional<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.Unknown>, Schema.Literal<false>]>>;
+  readonly commit: Schema.optional<Schema.Union<readonly [Schema.Boolean, Schema.String, Schema.$Array<Schema.Unknown>]>>;
+  readonly fixed: Schema.optional<Schema.$Array<Schema.$Array<Schema.String>>>;
+  readonly linked: Schema.optional<Schema.$Array<Schema.$Array<Schema.String>>>;
+  readonly access: Schema.optional<Schema.Literals<readonly ["public", "restricted"]>>;
+  readonly baseBranch: Schema.optional<Schema.String>;
+  readonly updateInternalDependencies: Schema.optional<Schema.Literals<readonly ["patch", "minor", "major"]>>;
+  readonly ignore: Schema.optional<Schema.$Array<Schema.String>>;
+  readonly privatePackages: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+    readonly tag: Schema.optional<Schema.Boolean>;
+    readonly version: Schema.optional<Schema.Boolean>;
+  }>, Schema.Literal<false>]>>;
+  readonly prettier: Schema.optional<Schema.Boolean>;
+  readonly changedFilePatterns: Schema.optional<Schema.$Array<Schema.String>>;
+  readonly bumpVersionsWithWorkspaceProtocolOnly: Schema.optional<Schema.Boolean>;
+  readonly snapshot: Schema.optional<Schema.Struct<{
+    readonly useCalculatedVersion: Schema.optional<Schema.Boolean>;
+    readonly prereleaseTemplate: Schema.optional<Schema.String>;
+  }>>;
+  readonly _isSilk: Schema.withConstructorDefault<Schema.withDecodingDefaultType<Schema.Boolean, never>>;
+}>;
+/**
+ * @since 0.1.0
+ * @public
+ */
+export type SilkChangesetConfigFile = typeof SilkChangesetConfigFile.Type;
+//#endregion
+//#region src/schemas/WorkspaceAnalysisSchemas.d.ts
+declare const SilkPublishConfig_base: Schema.Class<SilkPublishConfig, Schema.Struct<{
+  readonly access: Schema.optionalKey<Schema.Literals<readonly ["public", "restricted"]>>;
+  readonly registry: Schema.optionalKey<Schema.String>;
+  readonly directory: Schema.optionalKey<Schema.String>;
+  readonly linkDirectory: Schema.optionalKey<Schema.Boolean>;
+  readonly tag: Schema.optionalKey<Schema.String>;
+  targets: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Literals<readonly ["npm", "github", "jsr"]>, Schema.Struct<{
+    readonly protocol: Schema.withConstructorDefault<Schema.withDecodingDefaultType<Schema.Literals<readonly ["npm", "jsr"]>, never>>;
+    readonly registry: Schema.optional<Schema.String>;
+    readonly directory: Schema.optional<Schema.String>;
+    readonly access: Schema.optional<Schema.Literals<readonly ["public", "restricted"]>>;
+    readonly provenance: Schema.optional<Schema.Boolean>;
+    readonly tag: Schema.optional<Schema.String>;
+  }>]>>>;
+}>, PublishConfig> & Pick<{}, never>;
+/**
+ * Silk-extended publishConfig schema.
+ *
+ * @remarks
+ * Extends the base PublishConfig from `@effected/workspaces` (which covers the
+ * npm standard fields — access, registry, directory, tag — and, as of kit
+ * round 3, `linkDirectory`) with the Silk `targets` extension for
+ * multi-registry publishing.
+ *
+ * @since 0.2.0
+ * @public
+ */
+export declare class SilkPublishConfig extends SilkPublishConfig_base {}
+declare const AnalyzedWorkspace_base: Schema.Class<AnalyzedWorkspace, Schema.TaggedStruct<"AnalyzedWorkspace", {
+  readonly name: Schema.String;
+  readonly version: Schema.Struct<{
+    readonly current: Schema.optional<Schema.String>;
+  }>;
+  readonly path: Schema.String;
+  readonly root: Schema.Boolean;
+  readonly publishConfig: Schema.NullOr<typeof SilkPublishConfig>;
+  readonly publishable: Schema.Boolean;
+  readonly targets: Schema.$Array<typeof PublishTarget>;
+  readonly versioned: Schema.Boolean;
+  readonly tagged: Schema.Boolean;
+  readonly released: Schema.Boolean;
+  readonly linked: Schema.$Array<Schema.suspend<any>>;
+  readonly fixed: Schema.$Array<Schema.suspend<any>>;
+}>, {}>;
+/**
+ * A fully analyzed workspace with publish targets, versioning status,
+ * and release group membership.
+ *
+ * @since 0.2.0
+ * @public
+ */
+export declare class AnalyzedWorkspace extends AnalyzedWorkspace_base {
+  get isRoot(): boolean;
+  get isPublishable(): boolean;
+  get isReleasable(): boolean;
+  get isFixed(): boolean;
+  get isLinked(): boolean;
+  publishesTo(registry: string): boolean;
+  hasTarget(shorthand: "npm" | "github" | "jsr"): boolean;
+  targetFor(registry: string): Option.Option<PublishTarget>;
+  [Equal.symbol](that: Equal.Equal): boolean;
+  [Hash.symbol](): number;
+  toString(): string;
+  toJSON(): unknown;
+  static publishable(workspaces: ReadonlyArray<AnalyzedWorkspace>): ReadonlyArray<AnalyzedWorkspace>;
+  static releasable(workspaces: ReadonlyArray<AnalyzedWorkspace>): ReadonlyArray<AnalyzedWorkspace>;
+  static findByName: {
+    (name: string): (workspaces: ReadonlyArray<AnalyzedWorkspace>) => Option.Option<AnalyzedWorkspace>;
+    (workspaces: ReadonlyArray<AnalyzedWorkspace>, name: string): Option.Option<AnalyzedWorkspace>;
+  };
+  /** Pretty-print an AnalyzedWorkspace instance. */
+  static pretty: (self: AnalyzedWorkspace) => string;
+}
+declare const WorkspaceAnalysis_base: Schema.Class<WorkspaceAnalysis, Schema.TaggedStruct<"WorkspaceAnalysis", {
+  readonly root: Schema.String;
+  readonly runtime: Schema.Literals<readonly ["node", "bun"]>;
+  readonly packageManager: Schema.Struct<{
+    readonly type: Schema.Literals<readonly ["npm", "pnpm", "yarn", "bun"]>;
+    readonly version: Schema.optional<Schema.String>;
+  }>;
+  readonly workspaces: Schema.$Array<typeof AnalyzedWorkspace>;
+  readonly changesetConfig: Schema.NullOr<Schema.Union<readonly [Schema.Struct<{
+    readonly changelog: Schema.optional<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.Unknown>, Schema.Literal<false>]>>;
+    readonly commit: Schema.optional<Schema.Union<readonly [Schema.Boolean, Schema.String, Schema.$Array<Schema.Unknown>]>>;
+    readonly fixed: Schema.optional<Schema.$Array<Schema.$Array<Schema.String>>>;
+    readonly linked: Schema.optional<Schema.$Array<Schema.$Array<Schema.String>>>;
+    readonly access: Schema.optional<Schema.Literals<readonly ["public", "restricted"]>>;
+    readonly baseBranch: Schema.optional<Schema.String>;
+    readonly updateInternalDependencies: Schema.optional<Schema.Literals<readonly ["patch", "minor", "major"]>>;
+    readonly ignore: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly privatePackages: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+      readonly tag: Schema.optional<Schema.Boolean>;
+      readonly version: Schema.optional<Schema.Boolean>;
+    }>, Schema.Literal<false>]>>;
+    readonly prettier: Schema.optional<Schema.Boolean>;
+    readonly changedFilePatterns: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly bumpVersionsWithWorkspaceProtocolOnly: Schema.optional<Schema.Boolean>;
+    readonly snapshot: Schema.optional<Schema.Struct<{
+      readonly useCalculatedVersion: Schema.optional<Schema.Boolean>;
+      readonly prereleaseTemplate: Schema.optional<Schema.String>;
+    }>>;
+    readonly _isSilk: Schema.withConstructorDefault<Schema.withDecodingDefaultType<Schema.Boolean, never>>;
+  }>, Schema.Struct<{
+    readonly changelog: Schema.optional<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.Unknown>, Schema.Literal<false>]>>;
+    readonly commit: Schema.optional<Schema.Union<readonly [Schema.Boolean, Schema.String, Schema.$Array<Schema.Unknown>]>>;
+    readonly fixed: Schema.optional<Schema.$Array<Schema.$Array<Schema.String>>>;
+    readonly linked: Schema.optional<Schema.$Array<Schema.$Array<Schema.String>>>;
+    readonly access: Schema.optional<Schema.Literals<readonly ["public", "restricted"]>>;
+    readonly baseBranch: Schema.optional<Schema.String>;
+    readonly updateInternalDependencies: Schema.optional<Schema.Literals<readonly ["patch", "minor", "major"]>>;
+    readonly ignore: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly privatePackages: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+      readonly tag: Schema.optional<Schema.Boolean>;
+      readonly version: Schema.optional<Schema.Boolean>;
+    }>, Schema.Literal<false>]>>;
+    readonly prettier: Schema.optional<Schema.Boolean>;
+    readonly changedFilePatterns: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly bumpVersionsWithWorkspaceProtocolOnly: Schema.optional<Schema.Boolean>;
+    readonly snapshot: Schema.optional<Schema.Struct<{
+      readonly useCalculatedVersion: Schema.optional<Schema.Boolean>;
+      readonly prereleaseTemplate: Schema.optional<Schema.String>;
+    }>>;
+  }>]>>;
+  readonly versioning: Schema.NullOr<typeof VersioningStrategy>;
+  readonly tagStrategy: Schema.NullOr<Schema.Literals<readonly ["single", "scoped"]>>;
+}>, {}>;
+/**
+ * Full workspace analysis result containing all analyzed workspaces
+ * and project-level configuration.
+ *
+ * @since 0.2.0
+ * @public
+ */
+export declare class WorkspaceAnalysis extends WorkspaceAnalysis_base {
+  findWorkspace(name: string): Option.Option<AnalyzedWorkspace>;
+  get rootWorkspace(): Option.Option<AnalyzedWorkspace>;
+  get publishableWorkspaces(): ReadonlyArray<AnalyzedWorkspace>;
+  get versionedWorkspaces(): ReadonlyArray<AnalyzedWorkspace>;
+  get taggedWorkspaces(): ReadonlyArray<AnalyzedWorkspace>;
+  get releasableWorkspaces(): ReadonlyArray<AnalyzedWorkspace>;
+  get isSilk(): boolean;
+  get hasChangesets(): boolean;
+  [Equal.symbol](that: Equal.Equal): boolean;
+  [Hash.symbol](): number;
+  toString(): string;
+  /** Pretty-print a WorkspaceAnalysis instance. */
+  static pretty: (self: WorkspaceAnalysis) => string;
+}
+//#endregion
+//#region src/utils/TrailingSlash.d.ts
+/**
+ * Trim trailing slashes from a string.
+ *
+ * @remarks
+ * Trims trailing slashes with an index scan rather than `/\/+$/`. That regex is
+ * unanchored at the start, so the engine retries the match from every position
+ * and degrades to O(n²) on a string of many slashes (CodeQL `js/polynomial-redos`).
+ * Only a trailing run of slashes is removed; interior slash runs are untouched.
+ *
+ * @since 0.1.0
+ * @public
+ */
+export declare const trimTrailingSlashes: (s: string) => string;
+//#endregion
+export { index_d_exports as PrBody, type SavvyInstallHook };
+//# sourceMappingURL=index.d.ts.map