@williamthorsen/release-kit 4.8.0 → 5.1.0

package/dist/esm/showTagPrefixesCommand.js

@@ -0,0 +1,84 @@
+import { detectRepoType } from "./init/detectRepoType.js";
+import { previewTagPrefixes } from "./previewTagPrefixes.js";
+async function showTagPrefixesCommand() {
+  if (detectRepoType() === "single-package") {
+    process.stdout.write(renderSinglePackage());
+    return 0;
+  }
+  const preview = await previewTagPrefixes();
+  process.stdout.write(renderMonorepo(preview));
+  return computeExitCode(preview);
+}
+function renderSinglePackage() {
+  const lines = [
+    "Workspace   Derived prefix   Status",
+    ".           v                (single-package mode)",
+    ""
+  ];
+  return lines.join("\n");
+}
+function renderMonorepo(preview) {
+  const lines = ["Workspace tag prefixes:", ""];
+  for (const row of preview.workspaces) {
+    lines.push(...renderWorkspaceRow(row));
+  }
+  if (preview.collisions.length > 0) {
+    lines.push(
+      "",
+      ...preview.collisions.map(
+        (collision) => `\u26D4 tag prefix collision: '${collision.tagPrefix}' used by ${collision.workspacePaths.join(", ")}`
+      )
+    );
+  }
+  if (preview.undeclaredCandidates.length > 0) {
+    lines.push(
+      "",
+      "Undeclared tag prefixes:",
+      "",
+      ...preview.undeclaredCandidates.map(
+        (candidate) => `  '${candidate.prefix}' \u2014 ${candidate.tagCount} tags (e.g., ${candidate.exampleTags.join(", ")})`
+      ),
+      "",
+      "Suggested config snippet (adjust `dir` to match your workspace if the guess is wrong, and replace the `name` placeholder with the legacy npm name):",
+      "",
+      renderSuggestedSnippet(preview.undeclaredCandidates),
+      "",
+      "If the suggested `dir` does not match your workspace, adjust before pasting. Each legacy identity requires a `name` \u2014 replace the `TODO-fill-in-legacy-npm-name` placeholder with the package's prior npm name."
+    );
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function renderWorkspaceRow(row) {
+  const lines = [];
+  if (row.derivedPrefix === null) {
+    lines.push(`  ${row.workspacePath} \u2014 \u26D4 derivation failed: ${row.derivationError ?? "unknown error"}`);
+    return lines;
+  }
+  const statusMarker = row.derivedTagCount > 0 ? `\u2705 ${row.derivedTagCount} tags` : "\u26A0\uFE0F no existing tags";
+  lines.push(`  ${row.workspacePath} \u2014 derived prefix '${row.derivedPrefix}', ${statusMarker}`);
+  for (const entry of row.legacyEntries) {
+    if (entry.tagCount > 0) {
+      lines.push(`      \u2705 ${entry.tagCount} legacy tags with '${entry.prefix}' prefix (recognized)`);
+    } else {
+      lines.push(`      \u26A0\uFE0F recorded legacy prefix '${entry.prefix}' has no tags`);
+    }
+  }
+  return lines;
+}
+function renderSuggestedSnippet(candidates) {
+  const entries = candidates.map(
+    (candidate) => `    { dir: '${candidate.suggestedDir}', legacyIdentities: [{ name: 'TODO-fill-in-legacy-npm-name', tagPrefix: '${candidate.prefix}' }] },`
+  ).join("\n");
+  return `  workspaces: [
+${entries}
+  ],`;
+}
+function computeExitCode(preview) {
+  const hasDerivationFailure = preview.workspaces.some((row) => row.derivedPrefix === null);
+  const hasCollision = preview.collisions.length > 0;
+  return hasDerivationFailure || hasCollision ? 1 : 0;
+}
+export {
+  showTagPrefixesCommand
+};

package/dist/esm/sync-labels/initCommand.js

@@ -1,4 +1,4 @@
-import { reportWriteResult, writeFileWithCheck } from "@williamthorsen/node-monorepo-core";
+import { reportWriteResult, writeFileWithCheck } from "@williamthorsen/nmr-core";
 import { discoverWorkspaces } from "../discoverWorkspaces.js";
 import { generateCommand, LABELS_OUTPUT_PATH } from "./generateCommand.js";
 import { SYNC_LABELS_CONFIG_PATH } from "./loadSyncLabelsConfig.js";

package/dist/esm/sync-labels/presets.js

@@ -1,8 +1,8 @@
 import { createHash } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
+import { findPackageRoot } from "@williamthorsen/nmr-core";
 import { load } from "js-yaml";
-import { findPackageRoot } from "../findPackageRoot.js";
 import { isRecord } from "../typeGuards.js";
 function resolvePresetPath(presetName) {
   const root = findPackageRoot(import.meta.url);

package/dist/esm/tagCommand.js

@@ -1,4 +1,4 @@
-import { parseArgs, translateParseError } from "@williamthorsen/node-monorepo-core";
+import { parseArgs, translateParseError } from "@williamthorsen/nmr-core";
 import { createTags } from "./createTags.js";
 const tagFlagSchema = {
   dryRun: { long: "--dry-run", type: "boolean" },

package/dist/esm/types.d.ts

@@ -2,6 +2,7 @@ export type ReleaseType = 'major' | 'minor' | 'patch';
 export type ChangelogAudience = 'all' | 'dev';
 export interface ChangelogItem {
     description: string;
+    body?: string;
 }
 export interface ChangelogSection {
     title: string;
@@ -20,7 +21,12 @@ export interface ChangelogJsonConfig {
 }
 export interface ReleaseNotesConfig {
     shouldInjectIntoReadme: boolean;
-    shouldCreateGithubRelease: boolean;
+}
+export interface ProjectConfig {
+    tagPrefix?: string;
+}
+export interface ResolvedProjectConfig {
+    tagPrefix: string;
 }
 export interface PropagationSource {
     packageName: string;
@@ -31,25 +37,60 @@ export interface BumpResult {
     newVersion: string;
     files: string[];
 }
-export interface ComponentPrepareResult {
-    name?: string | undefined;
-    status: 'released' | 'skipped';
-    previousTag?: string | undefined;
+export interface ReleasedWorkspaceResult {
+    status: 'released';
+    name?: string;
+    previousTag?: string;
     commitCount: number;
-    parsedCommitCount?: number | undefined;
-    releaseType?: ReleaseType | undefined;
-    currentVersion?: string | undefined;
-    newVersion?: string | undefined;
-    tag?: string | undefined;
+    parsedCommitCount?: number;
+    unparseableCommits?: Commit[];
+    releaseType?: ReleaseType;
+    currentVersion: string;
+    newVersion: string;
+    tag: string;
     bumpedFiles: string[];
     changelogFiles: string[];
-    commits?: Commit[] | undefined;
-    unparseableCommits?: Commit[] | undefined;
-    propagatedFrom?: PropagationSource[] | undefined;
-    skipReason?: string | undefined;
+    commits?: Commit[];
+    bumpOverride?: ReleaseType;
+    propagatedFrom?: PropagationSource[];
+    setVersion?: string;
+}
+export interface SkippedWorkspaceResult {
+    status: 'skipped';
+    name?: string;
+    previousTag?: string;
+    commitCount: number;
+    parsedCommitCount?: number;
+    unparseableCommits?: Commit[];
+    skipReason: string;
+}
+export type WorkspacePrepareResult = ReleasedWorkspaceResult | SkippedWorkspaceResult;
+export interface ReleasedProjectResult {
+    status: 'released';
+    previousTag?: string;
+    commitCount: number;
+    parsedCommitCount: number;
+    unparseableCommits?: Commit[];
+    releaseType: ReleaseType;
+    currentVersion: string;
+    newVersion: string;
+    tag: string;
+    bumpedFiles: string[];
+    changelogFiles: string[];
+    commits: Commit[];
+    bumpOverride?: ReleaseType;
+}
+export interface SkippedProjectResult {
+    status: 'skipped';
+    previousTag?: string;
+    commitCount: number;
+    parsedCommitCount: number;
+    unparseableCommits?: Commit[];
+    skipReason: string;
 }
+export type ProjectPrepareResult = ReleasedProjectResult | SkippedProjectResult;
 export interface PrepareResult {
-    components: ComponentPrepareResult[];
+    workspaces: WorkspacePrepareResult[];
     tags: string[];
     formatCommand?: {
         command: string;
@@ -58,6 +99,7 @@ export interface PrepareResult {
     } | undefined;
     dryRun: boolean;
     warnings?: string[] | undefined;
+    project?: ProjectPrepareResult | undefined;
 }
 export interface WorkTypeConfig {
     header: string;
@@ -68,7 +110,7 @@ export interface VersionPatterns {
     minor: string[];
 }
 export interface ReleaseKitConfig {
-    components?: ComponentOverride[];
+    workspaces?: WorkspaceOverride[];
     versionPatterns?: VersionPatterns;
     workTypes?: Record<string, WorkTypeConfig>;
     formatCommand?: string;
@@ -76,10 +118,22 @@ export interface ReleaseKitConfig {
     scopeAliases?: Record<string, string>;
     changelogJson?: Partial<ChangelogJsonConfig>;
     releaseNotes?: Partial<ReleaseNotesConfig>;
+    retiredPackages?: RetiredPackage[];
+    project?: ProjectConfig;
+}
+export interface LegacyIdentity {
+    name: string;
+    tagPrefix: string;
+}
+export interface RetiredPackage {
+    name: string;
+    tagPrefix: string;
+    successor?: string;
 }
-export interface ComponentOverride {
+export interface WorkspaceOverride {
     dir: string;
     shouldExclude?: boolean;
+    legacyIdentities?: LegacyIdentity[];
 }
 export interface Commit {
     message: string;
@@ -93,15 +147,18 @@ export interface ParsedCommit {
     scope?: string;
     breaking: boolean;
 }
-export interface ComponentConfig {
+export interface WorkspaceConfig {
     dir: string;
+    name: string;
     tagPrefix: string;
+    workspacePath: string;
     packageFiles: string[];
     changelogPaths: string[];
     paths: string[];
+    legacyIdentities?: LegacyIdentity[];
 }
 export interface MonorepoReleaseConfig {
-    components: ComponentConfig[];
+    workspaces: WorkspaceConfig[];
     workTypes?: Record<string, WorkTypeConfig>;
     versionPatterns?: VersionPatterns;
     formatCommand?: string;
@@ -109,6 +166,7 @@ export interface MonorepoReleaseConfig {
     scopeAliases?: Record<string, string>;
     changelogJson: ChangelogJsonConfig;
     releaseNotes: ReleaseNotesConfig;
+    project?: ResolvedProjectConfig;
 }
 export interface ReleaseConfig {
     tagPrefix: string;

package/dist/esm/validateConfig.js

@@ -8,11 +8,13 @@ function validateConfig(raw) {
   const knownFields = /* @__PURE__ */ new Set([
     "changelogJson",
     "cliffConfigPath",
-    "components",
     "formatCommand",
+    "project",
     "releaseNotes",
+    "retiredPackages",
     "scopeAliases",
     "versionPatterns",
+    "workspaces",
     "workTypes"
   ]);
   for (const key of Object.keys(raw)) {
@@ -21,26 +23,21 @@ function validateConfig(raw) {
     }
   }
   validateChangelogJson(raw.changelogJson, config, errors);
-  validateComponents(raw.components, config, errors);
+  validateWorkspaces(raw.workspaces, config, errors);
   validateReleaseNotes(raw.releaseNotes, config, errors);
   validateVersionPatterns(raw.versionPatterns, config, errors);
   validateWorkTypes(raw.workTypes, config, errors);
   validateStringField("formatCommand", raw.formatCommand, config, errors);
   validateStringField("cliffConfigPath", raw.cliffConfigPath, config, errors);
   validateScopeAliases(raw.scopeAliases, config, errors);
+  validateRetiredPackages(raw.retiredPackages, config, errors);
+  validateProjectConfig(raw.project, config, errors);
   const warnings = [];
   const changelogJsonEnabled = config.changelogJson?.enabled ?? true;
-  if (!changelogJsonEnabled) {
-    if (config.releaseNotes?.shouldCreateGithubRelease) {
-      warnings.push(
-        "releaseNotes.shouldCreateGithubRelease is enabled but changelogJson.enabled is false; GitHub Releases will be skipped at runtime"
-      );
-    }
-    if (config.releaseNotes?.shouldInjectIntoReadme) {
-      warnings.push(
-        "releaseNotes.shouldInjectIntoReadme is enabled but changelogJson.enabled is false; README injection will be skipped at runtime"
-      );
-    }
+  if (!changelogJsonEnabled && config.releaseNotes?.shouldInjectIntoReadme) {
+    warnings.push(
+      "releaseNotes.shouldInjectIntoReadme is enabled but changelogJson.enabled is false; README injection will be skipped at runtime"
+    );
   }
   return { config, errors, warnings };
 }
@@ -80,16 +77,46 @@ function validateChangelogJson(value, config, errors) {
   }
   config.changelogJson = result;
 }
+function validateProjectConfig(value, config, errors) {
+  if (value === void 0) return;
+  if (!isRecord(value)) {
+    errors.push("'project' must be an object");
+    return;
+  }
+  const knownProjectFields = /* @__PURE__ */ new Set(["tagPrefix"]);
+  for (const key of Object.keys(value)) {
+    if (!knownProjectFields.has(key)) {
+      errors.push(`project: unknown field '${key}'`);
+    }
+  }
+  const result = {};
+  if (value.tagPrefix !== void 0) {
+    if (typeof value.tagPrefix !== "string") {
+      errors.push("project.tagPrefix: must be a string");
+    } else if (value.tagPrefix === "") {
+      errors.push("project.tagPrefix: must be a non-empty string");
+    } else {
+      result.tagPrefix = value.tagPrefix;
+    }
+  }
+  config.project = result;
+}
 function validateReleaseNotes(value, config, errors) {
   if (value === void 0) return;
   if (!isRecord(value)) {
     errors.push("'releaseNotes' must be an object");
     return;
   }
-  const knownReleaseNotesFields = /* @__PURE__ */ new Set(["shouldInjectIntoReadme", "shouldCreateGithubRelease"]);
+  const knownReleaseNotesFields = /* @__PURE__ */ new Set(["shouldInjectIntoReadme"]);
   for (const key of Object.keys(value)) {
     if (!knownReleaseNotesFields.has(key)) {
-      errors.push(`releaseNotes: unknown field '${key}'`);
+      if (key === "shouldCreateGithubRelease") {
+        errors.push(
+          "releaseNotes.shouldCreateGithubRelease is no longer supported. Adoption is now signaled by installing the create-github-release workflow. Remove this field from your config; see README for the updated workflow."
+        );
+      } else {
+        errors.push(`releaseNotes: unknown field '${key}'`);
+      }
     }
   }
   const result = {};
@@ -100,57 +127,199 @@ function validateReleaseNotes(value, config, errors) {
       errors.push("releaseNotes.shouldInjectIntoReadme: must be a boolean");
     }
   }
-  if (value.shouldCreateGithubRelease !== void 0) {
-    if (typeof value.shouldCreateGithubRelease === "boolean") {
-      result.shouldCreateGithubRelease = value.shouldCreateGithubRelease;
-    } else {
-      errors.push("releaseNotes.shouldCreateGithubRelease: must be a boolean");
-    }
-  }
   config.releaseNotes = result;
 }
 function isStringArray(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "string");
 }
-function validateComponents(value, config, errors) {
+function validateWorkspaces(value, config, errors) {
   if (value === void 0) return;
   if (!Array.isArray(value)) {
-    errors.push("'components' must be an array");
+    errors.push("'workspaces' must be an array");
     return;
   }
-  const components = [];
-  const knownComponentFields = /* @__PURE__ */ new Set(["dir", "shouldExclude"]);
+  const workspaces = [];
+  const knownWorkspaceFields = /* @__PURE__ */ new Set(["dir", "shouldExclude", "legacyIdentities"]);
   for (const [i, entry] of value.entries()) {
     if (!isRecord(entry)) {
-      errors.push(`components[${i}]: must be an object`);
+      errors.push(`workspaces[${i}]: must be an object`);
       continue;
     }
     if (typeof entry.dir !== "string" || entry.dir === "") {
-      errors.push(`components[${i}]: 'dir' is required`);
+      errors.push(`workspaces[${i}]: 'dir' is required`);
       continue;
     }
     for (const key of Object.keys(entry)) {
-      if (!knownComponentFields.has(key)) {
+      if (!knownWorkspaceFields.has(key)) {
         if (key === "tagPrefix") {
           errors.push(
-            `components[${i}]: 'tagPrefix' is no longer supported; remove it to use the default '${entry.dir}-v'`
+            `workspaces[${i}]: 'tagPrefix' is no longer supported; remove it to use the default '${entry.dir}-v'`
+          );
+        } else if (key === "legacyTagPrefixes") {
+          errors.push(
+            `workspaces[${i}]: 'legacyTagPrefixes' is no longer supported; use 'legacyIdentities: [{ name, tagPrefix }, ...]' instead`
           );
         } else {
-          errors.push(`components[${i}]: unknown field '${key}'`);
+          errors.push(`workspaces[${i}]: unknown field '${key}'`);
         }
       }
     }
-    const component = { dir: entry.dir };
+    const workspace = { dir: entry.dir };
     if (entry.shouldExclude !== void 0) {
       if (typeof entry.shouldExclude === "boolean") {
-        component.shouldExclude = entry.shouldExclude;
+        workspace.shouldExclude = entry.shouldExclude;
       } else {
-        errors.push(`components[${i}]: 'shouldExclude' must be a boolean`);
+        errors.push(`workspaces[${i}]: 'shouldExclude' must be a boolean`);
+      }
+    }
+    if (entry.legacyIdentities !== void 0) {
+      const identities = validateLegacyIdentities(entry.legacyIdentities, i, errors);
+      if (identities !== void 0) {
+        workspace.legacyIdentities = identities;
+      }
+    }
+    workspaces.push(workspace);
+  }
+  config.workspaces = workspaces;
+}
+function validateLegacyIdentities(value, workspaceIndex, errors) {
+  if (!Array.isArray(value)) {
+    errors.push(`workspaces[${workspaceIndex}]: 'legacyIdentities' must be an array`);
+    return void 0;
+  }
+  const knownIdentityFields = /* @__PURE__ */ new Set(["name", "tagPrefix"]);
+  const identities = [];
+  const seenTuples = /* @__PURE__ */ new Set();
+  for (const [entryIndex, entry] of value.entries()) {
+    if (!isRecord(entry)) {
+      errors.push(`workspaces[${workspaceIndex}].legacyIdentities[${entryIndex}]: must be an object`);
+      continue;
+    }
+    let entryValid = true;
+    for (const key2 of Object.keys(entry)) {
+      if (!knownIdentityFields.has(key2)) {
+        errors.push(`workspaces[${workspaceIndex}].legacyIdentities[${entryIndex}]: unknown field '${key2}'`);
+        entryValid = false;
+      }
+    }
+    const { name, tagPrefix } = entry;
+    if (typeof name !== "string") {
+      errors.push(`workspaces[${workspaceIndex}].legacyIdentities[${entryIndex}].name: must be a string`);
+      entryValid = false;
+    } else if (name === "") {
+      errors.push(`workspaces[${workspaceIndex}].legacyIdentities[${entryIndex}].name: must be a non-empty string`);
+      entryValid = false;
+    }
+    if (typeof tagPrefix !== "string") {
+      errors.push(`workspaces[${workspaceIndex}].legacyIdentities[${entryIndex}].tagPrefix: must be a string`);
+      entryValid = false;
+    } else if (tagPrefix === "") {
+      errors.push(
+        `workspaces[${workspaceIndex}].legacyIdentities[${entryIndex}].tagPrefix: must be a non-empty string`
+      );
+      entryValid = false;
+    }
+    if (!entryValid || typeof name !== "string" || typeof tagPrefix !== "string") {
+      continue;
+    }
+    const key = `${name}\0${tagPrefix}`;
+    if (seenTuples.has(key)) {
+      errors.push(
+        `workspaces[${workspaceIndex}].legacyIdentities[${entryIndex}]: duplicate identity (name='${name}', tagPrefix='${tagPrefix}')`
+      );
+      continue;
+    }
+    seenTuples.add(key);
+    identities.push({ name, tagPrefix });
+  }
+  return identities;
+}
+function validateRetiredPackages(value, config, errors) {
+  if (value === void 0) return;
+  if (!Array.isArray(value)) {
+    errors.push("'retiredPackages' must be an array");
+    return;
+  }
+  const validEntries = [];
+  const seenTuples = /* @__PURE__ */ new Set();
+  for (const [i, entry] of value.entries()) {
+    const retired = validateRetiredPackageEntry(entry, i, errors);
+    if (retired === void 0) continue;
+    const key = `${retired.name}\0${retired.tagPrefix}`;
+    if (seenTuples.has(key)) {
+      errors.push(
+        `retiredPackages[${i}]: duplicate package (name='${retired.name}', tagPrefix='${retired.tagPrefix}')`
+      );
+      continue;
+    }
+    seenTuples.add(key);
+    validEntries.push({ entry: retired, rawIndex: i });
+  }
+  detectRetiredVsLegacyCollisions(validEntries, config, errors);
+  config.retiredPackages = validEntries.map(({ entry }) => entry);
+}
+function validateRetiredPackageEntry(entry, i, errors) {
+  if (!isRecord(entry)) {
+    errors.push(`retiredPackages[${i}]: must be an object`);
+    return void 0;
+  }
+  const knownRetiredFields = /* @__PURE__ */ new Set(["name", "tagPrefix", "successor"]);
+  let entryValid = true;
+  for (const key of Object.keys(entry)) {
+    if (!knownRetiredFields.has(key)) {
+      errors.push(`retiredPackages[${i}]: unknown field '${key}'`);
+      entryValid = false;
+    }
+  }
+  const { name, tagPrefix, successor } = entry;
+  if (!validateNonEmptyString(name, `retiredPackages[${i}].name`, errors)) {
+    entryValid = false;
+  }
+  if (!validateNonEmptyString(tagPrefix, `retiredPackages[${i}].tagPrefix`, errors)) {
+    entryValid = false;
+  }
+  if (successor !== void 0 && !validateNonEmptyString(successor, `retiredPackages[${i}].successor`, errors)) {
+    entryValid = false;
+  }
+  if (!entryValid || typeof name !== "string" || typeof tagPrefix !== "string") {
+    return void 0;
+  }
+  const retired = { name, tagPrefix };
+  if (typeof successor === "string" && successor !== "") {
+    retired.successor = successor;
+  }
+  return retired;
+}
+function detectRetiredVsLegacyCollisions(retiredPackages, config, errors) {
+  if (config.workspaces === void 0) return;
+  const legacyPrefixToWorkspace = /* @__PURE__ */ new Map();
+  for (const workspace of config.workspaces) {
+    if (workspace.legacyIdentities === void 0) continue;
+    for (const identity of workspace.legacyIdentities) {
+      if (!legacyPrefixToWorkspace.has(identity.tagPrefix)) {
+        legacyPrefixToWorkspace.set(identity.tagPrefix, workspace.dir);
       }
     }
-    components.push(component);
   }
-  config.components = components;
+  for (const { entry: retired, rawIndex } of retiredPackages) {
+    const collidingDir = legacyPrefixToWorkspace.get(retired.tagPrefix);
+    if (collidingDir !== void 0) {
+      errors.push(
+        `retiredPackages[${rawIndex}]: tagPrefix '${retired.tagPrefix}' collides with a declared legacyIdentities[].tagPrefix on workspace '${collidingDir}'`
+      );
+    }
+  }
+}
+function validateNonEmptyString(value, fieldPath, errors) {
+  if (typeof value !== "string") {
+    errors.push(`${fieldPath}: must be a string`);
+    return false;
+  }
+  if (value === "") {
+    errors.push(`${fieldPath}: must be a non-empty string`);
+    return false;
+  }
+  return true;
 }
 function validateVersionPatterns(value, config, errors) {
   if (value === void 0) return;

package/dist/esm/validateOnlyExcludesStrandedDependents.d.ts

@@ -0,0 +1,14 @@
+import type { DependencyGraph } from './buildDependencyGraph.ts';
+import type { WorkspaceConfig } from './types.ts';
+export interface CommitsProbeResult {
+    has: boolean;
+    tag: string | undefined;
+}
+export interface StrandedDependentViolation {
+    dir: string;
+    downstreamOf: string;
+    tag: string | undefined;
+}
+type CommitsProbe = (workspace: WorkspaceConfig) => CommitsProbeResult;
+export declare function validateOnlyExcludesStrandedDependents(workspaces: readonly WorkspaceConfig[], only: readonly string[], graph: DependencyGraph, hasCommits: CommitsProbe): StrandedDependentViolation[] | undefined;
+export {};