@treeseed/sdk 0.10.28 → 0.12.4

package/dist/operations/services/package-reference-policy.d.ts

@@ -1,7 +1,5 @@
-export type DevDependencyReferenceMode = 'git-tag' | 'registry-prerelease';
-export type DevTagCleanupMode = 'safe-after-release' | 'off';
+export type DevDependencyReferenceMode = 'git-commit';
 export type GitDependencyProtocol = 'preserve-origin' | 'https' | 'ssh';
-export type DevTagBranchScope = 'staging' | 'preview' | 'all';
 export type PackageDependencyReference = {
     packageName: string;
     version: string;
@@ -10,7 +8,7 @@ export type PackageDependencyReference = {
     installSpec: string;
     tagName: string | null;
     remoteUrl: string | null;
-    mode: 'stable-semver' | 'dev-git-tag' | 'dev-registry-prerelease';
+    mode: 'stable-semver' | 'dev-git-commit';
 };
 export type RewrittenDevReference = {
     packageName: string;
@@ -19,22 +17,6 @@ export type RewrittenDevReference = {
     to: string;
     tagName: string | null;
 };
-export type TreeseedDevTagInfo = {
-    tagName: string;
-    stableVersion: string;
-    branchSlug: string;
-    timestamp: string;
-    metadata: Record<string, string>;
-    branch: string | null;
-    packageName: string | null;
-    version: string | null;
-};
-export type StaleDevTagClassification = {
-    tagName: string;
-    action: 'delete' | 'skip';
-    reason: string;
-    info: TreeseedDevTagInfo | null;
-};
 export declare function internalDependencyFields(packageJson: Record<string, unknown> | null): string[];
 export declare function isPrereleaseVersion(version: string): boolean;
 export declare function isStableVersion(version: string): boolean;
@@ -48,10 +30,12 @@ export declare function createPackageDependencyReference(input: {
     version: string;
     branchMode: 'package-release-main' | 'package-dev-save';
     remoteUrl?: string | null;
+    commitSha?: string | null;
     devDependencyReferenceMode?: DevDependencyReferenceMode;
     gitDependencyProtocol?: GitDependencyProtocol;
 }): PackageDependencyReference;
 export declare function updateInternalDependencySpecs(packageJson: Record<string, unknown> | null, references: Map<string, PackageDependencyReference>): RewrittenDevReference[];
+export declare function installableInternalDependencyVersions(root: any, versions: Map<string, string>): Map<string, string>;
 export declare function rewriteInternalDependenciesToStableVersions(root: any, versions: Map<string, string>): (RewrittenDevReference & {
     repoName: string;
     packageJsonPath: string;
@@ -68,72 +52,13 @@ export declare function collectInternalDevReferenceIssues(root?: any, packageNam
     spec: string;
     reason: string;
 }[];
+export declare function collectDevelopmentCommitReferenceIssues(root?: any, packageNames?: Set<any>): {
+    repoName: string;
+    filePath: string;
+    field?: string;
+    dependencyName?: string;
+    spec: string;
+    reason: string;
+}[];
+export declare function assertDevelopmentInternalCommitReferences(root?: any, packageNames?: Set<string>): void;
 export declare function assertNoInternalDevReferences(root?: any, packageNames?: Set<string>): void;
-export declare function createDevTagMessage(input: {
-    packageName: string;
-    version: string;
-    branch: string;
-    commitSha: string;
-    workflowRunId?: string | null;
-    createdAt?: string;
-}): string;
-export declare function gitTagMessage(repoDir: string, tagName: string): string;
-export declare function tagHasTreeseedDevMetadata(repoDir: string, tagName: string): boolean;
-export declare function parseTreeseedDevTag(tagName: string, message: string): TreeseedDevTagInfo | null;
-export declare function classifyStaleTreeseedDevTag(input: {
-    tagName: string;
-    message: string;
-    currentVersion: string;
-    activeReferences?: string[];
-    branchScope?: DevTagBranchScope;
-    expectedPackageName?: string | null;
-}): StaleDevTagClassification;
-export declare function cleanupDevTags(repoDir: string, tagNames: string[], activeReferences?: string[]): {
-    cleaned: string[];
-    skipped: {
-        tagName: string;
-        reason: string;
-    }[];
-};
-export declare function collectTreeseedDevTagCleanupPlan(input: {
-    repoDir: string;
-    packageName: string;
-    currentVersion: string;
-    activeReferences?: string[];
-    branchScope?: DevTagBranchScope;
-}): {
-    packageName: string;
-    currentVersion: string;
-    branchScope: DevTagBranchScope;
-    candidates: StaleDevTagClassification[];
-    skipped: StaleDevTagClassification[];
-    tags: StaleDevTagClassification[];
-};
-export declare function cleanupStaleTreeseedDevTags(input: {
-    repoDir: string;
-    packageName: string;
-    currentVersion: string;
-    activeReferences?: string[];
-    branchScope?: DevTagBranchScope;
-    dryRun?: boolean;
-}): {
-    status: string;
-    packageName: string;
-    currentVersion: string;
-    branchScope: DevTagBranchScope;
-    candidates: {
-        tagName: string;
-        reason: string;
-        branch: string | null | undefined;
-        branchSlug: string | undefined;
-        version: string | null | undefined;
-    }[];
-    candidateCount: number;
-    cleaned: string[];
-    cleanedCount: number;
-    skipped: {
-        tagName: string;
-        reason: string;
-    }[];
-    skippedCount: number;
-};

package/dist/operations/services/package-reference-policy.js

@@ -1,7 +1,8 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
-import { run, workspacePackages, workspaceRoot } from "./workspace-tools.js";
+import { discoverTreeseedPackageAdapters } from "./package-adapters.js";
+import { workspacePackages, workspaceRoot } from "./workspace-tools.js";
 const INTERNAL_DEPENDENCY_FIELDS = ["dependencies", "optionalDependencies", "peerDependencies", "devDependencies"];
 function readJson(filePath) {
   return JSON.parse(readFileSync(filePath, "utf8"));
@@ -20,19 +21,6 @@ function isPrereleaseVersion(version) {
 function isStableVersion(version) {
   return /^\d+\.\d+\.\d+$/u.test(String(version).trim());
 }
-function stableVersionBase(version) {
-  const match = String(version).trim().match(/^(\d+\.\d+\.\d+)(?:-|$)/u);
-  return match?.[1] ?? null;
-}
-function compareStableVersions(left, right) {
-  const leftParts = left.split(".").map((part) => Number(part));
-  const rightParts = right.split(".").map((part) => Number(part));
-  for (let index = 0; index < 3; index += 1) {
-    const difference = (leftParts[index] ?? 0) - (rightParts[index] ?? 0);
-    if (difference !== 0) return difference;
-  }
-  return 0;
-}
 function isGitDependencySpec(spec) {
   return /^(?:git\+|github:|gitlab:|bitbucket:|ssh:\/\/|https:\/\/|file:)/u.test(String(spec).trim()) && String(spec).includes("#");
 }
@@ -104,33 +92,25 @@ function createPackageDependencyReference(input) {
       mode: "stable-semver"
     };
   }
-  if ((input.devDependencyReferenceMode ?? "git-tag") === "registry-prerelease") {
-    return {
-      packageName: input.packageName,
-      version: input.version,
-      spec: input.version,
-      manifestSpec: input.version,
-      installSpec: input.version,
-      tagName: input.version,
-      remoteUrl: input.remoteUrl ?? null,
-      mode: "dev-registry-prerelease"
-    };
-  }
   const installRemote = normalizeGitRemoteForDependency(input.remoteUrl ?? "", input.gitDependencyProtocol ?? "preserve-origin");
   const manifestRemote = normalizeGitRemoteForManifest(input.remoteUrl ?? "", input.gitDependencyProtocol ?? "preserve-origin");
   if (!installRemote || !manifestRemote) {
-    throw new Error(`Unable to create Git-tag dependency for ${input.packageName}; origin remote is missing.`);
+    throw new Error(`Unable to create Git dependency for ${input.packageName}; origin remote is missing.`);
+  }
+  const ref = String(input.commitSha ?? "").trim();
+  if (!ref) {
+    throw new Error(`Unable to create commit dependency for ${input.packageName}; commit SHA is missing.`);
   }
-  const manifestSpec = `${manifestRemote}#${input.version}`;
+  const manifestSpec = `${manifestRemote}#${ref}`;
   return {
     packageName: input.packageName,
     version: input.version,
     spec: manifestSpec,
     manifestSpec,
     installSpec: manifestSpec,
-    tagName: input.version,
+    tagName: null,
     remoteUrl: input.remoteUrl ?? null,
-    mode: "dev-git-tag"
+    mode: "dev-git-commit"
   };
 }
 function updateInternalDependencySpecs(packageJson, references) {
@@ -155,14 +135,24 @@ function updateInternalDependencySpecs(packageJson, references) {
   }
   return changed;
 }
+function installableInternalDependencyVersions(root = workspaceRoot(), versions) {
+  const publishTargets = /* @__PURE__ */ new Map();
+  for (const adapter of discoverTreeseedPackageAdapters(root)) {
+    const publishTarget = adapter.publishTarget ?? "npm";
+    publishTargets.set(adapter.id, publishTarget);
+    publishTargets.set(adapter.name, publishTarget);
+  }
+  return new Map([...versions.entries()].filter(([packageName]) => (publishTargets.get(packageName) ?? "npm") === "npm"));
+}
 function rewriteInternalDependenciesToStableVersions(root = workspaceRoot(), versions) {
   const rewrites = [];
+  const installableVersions = installableInternalDependencyVersions(root, versions);
   for (const pkg of workspacePackages(root)) {
     const packageJsonPath = resolve(pkg.dir, "package.json");
     const packageJson = readJson(packageJsonPath);
     const changed = updateInternalDependencySpecs(
       packageJson,
-      new Map([...versions.entries()].map(([packageName, version]) => [packageName, {
+      new Map([...installableVersions.entries()].map(([packageName, version]) => [packageName, {
         packageName,
         version,
         spec: version,
@@ -185,6 +175,7 @@ function rewriteInternalDependenciesToStableVersions(root = workspaceRoot(), ver
 }
 function rewriteProjectInternalDependenciesToStableVersions(root = workspaceRoot(), versions) {
   const rewrites = [];
+  const installableVersions = installableInternalDependencyVersions(root, versions);
   const targets = [
     { name: "@treeseed/market", dir: root },
     ...workspacePackages(root).map((pkg) => ({ name: pkg.name, dir: pkg.dir }))
@@ -195,7 +186,7 @@ function rewriteProjectInternalDependenciesToStableVersions(root = workspaceRoot
     const packageJson = readJson(packageJsonPath);
     const changed = updateInternalDependencySpecs(
       packageJson,
-      new Map([...versions.entries()].map(([packageName, version]) => [packageName, {
+      new Map([...installableVersions.entries()].map(([packageName, version]) => [packageName, {
         packageName,
         version,
         spec: version,
@@ -231,8 +222,8 @@ function collectInternalDevReferenceIssues(root = workspaceRoot(), packageNames
       for (const [depName, specValue] of Object.entries(values)) {
         if (!packageNames.has(depName)) continue;
         const spec = String(specValue);
-        if (isGitDependencySpec(spec) && !releaseTagFromDependencySpec(spec)) {
-          issues.push({ repoName: pkg.name, filePath: packageJsonPath, field, dependencyName: depName, spec, reason: "git-dev-ref" });
+        if (isGitDependencySpec(spec)) {
+          issues.push({ repoName: pkg.name, filePath: packageJsonPath, field, dependencyName: depName, spec, reason: releaseTagFromDependencySpec(spec) ? "git-release-ref" : "git-dev-ref" });
         } else if (isPrereleaseVersion(spec)) {
           issues.push({ repoName: pkg.name, filePath: packageJsonPath, field, dependencyName: depName, spec, reason: "prerelease-dev-ref" });
         }
@@ -259,10 +250,10 @@ function collectInternalDevReferenceIssues(root = workspaceRoot(), packageNames
             record.resolved,
             record.from
           ].map((value) => typeof value === "string" ? value : "").find(
-            (value) => isGitDependencySpec(value) && !releaseTagFromDependencySpec(value) || devTagFromDependencySpec(value) || isPrereleaseVersion(value)
+            (value) => isGitDependencySpec(value) || devTagFromDependencySpec(value) || isPrereleaseVersion(value)
           );
           if (spec) {
-            issues.push({ repoName: lockRoot.name, filePath: lockPath, spec, reason: "lockfile-dev-ref", dependencyName: packageName });
+            issues.push({ repoName: lockRoot.name, filePath: lockPath, spec, reason: releaseTagFromDependencySpec(spec) ? "lockfile-git-release-ref" : "lockfile-dev-ref", dependencyName: packageName });
           }
         }
       }
@@ -270,204 +261,94 @@ function collectInternalDevReferenceIssues(root = workspaceRoot(), packageNames
   }
   return issues;
 }
-function assertNoInternalDevReferences(root = workspaceRoot(), packageNames) {
-  const issues = collectInternalDevReferenceIssues(root, packageNames);
-  if (issues.length === 0) return;
-  const rendered = issues.map((issue) => `${issue.filePath}${issue.field ? ` ${issue.field}.${issue.dependencyName}` : ""}: ${issue.reason} ${issue.spec}`).join("\n");
-  throw new Error(`Stable release still contains internal Git/dev dependency references.
-${rendered}`);
-}
-function createDevTagMessage(input) {
-  const branchSlug = input.branch.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "dev";
-  return [
-    `save: ${input.packageName} ${input.version}`,
-    "",
-    "treeseed-dev-tag: true",
-    `package: ${input.packageName}`,
-    `version: ${input.version}`,
-    `branch: ${input.branch}`,
-    `branchSlug: ${branchSlug}`,
-    `createdAt: ${input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()}`,
-    `workflowRunId: ${input.workflowRunId ?? ""}`,
-    `commitSha: ${input.commitSha}`
-  ].join("\n");
-}
-function gitTagMessage(repoDir, tagName) {
-  try {
-    return run("git", ["tag", "-l", tagName, "--format=%(contents)"], { cwd: repoDir, capture: true });
-  } catch {
-    return "";
-  }
-}
-function gitRemoteTagMessage(repoDir, tagName) {
-  try {
-    run("git", ["fetch", "--no-tags", "origin", `refs/tags/${tagName}`], { cwd: repoDir, capture: true });
-    return run("git", ["cat-file", "-p", "FETCH_HEAD"], { cwd: repoDir, capture: true });
-  } catch {
-    return "";
-  }
-}
-function gitDevTagMessage(repoDir, tagName) {
-  const local = gitTagMessage(repoDir, tagName);
-  if (local.trim()) return local;
-  return gitRemoteTagMessage(repoDir, tagName);
-}
-function tagHasTreeseedDevMetadata(repoDir, tagName) {
-  return gitTagMessage(repoDir, tagName).includes("treeseed-dev-tag: true");
-}
-function parseTreeseedDevTag(tagName, message) {
-  const match = String(tagName).match(/^(\d+\.\d+\.\d+)-dev\.([0-9A-Za-z.-]+)\.(\d{8}T\d{6}Z)$/u);
-  if (!match) return null;
-  const metadata = Object.fromEntries(
-    String(message).split(/\r?\n/u).map((line) => line.match(/^([^:]+):\s*(.*)$/u)).filter((lineMatch) => Boolean(lineMatch)).map((lineMatch) => [String(lineMatch[1]).trim(), String(lineMatch[2] ?? "").trim()])
-  );
-  if (metadata["treeseed-dev-tag"] !== "true") return null;
-  return {
-    tagName,
-    stableVersion: match[1],
-    branchSlug: match[2],
-    timestamp: match[3],
-    metadata,
-    branch: metadata.branch || null,
-    packageName: metadata.package || null,
-    version: metadata.version || null
-  };
-}
-function devTagScope(info) {
-  const branch = info.branch ?? info.branchSlug;
-  if (branch === "staging" || info.branchSlug === "staging") return "staging";
-  if (branch === "main" || branch === "prod" || branch === "production" || info.branchSlug === "main" || info.branchSlug === "prod" || info.branchSlug === "production") return "main";
-  return "preview";
-}
-function classifyStaleTreeseedDevTag(input) {
-  const tagName = String(input.tagName).trim();
-  if (!tagName.includes("-dev.")) return { tagName, action: "skip", reason: "not-dev-tag", info: null };
-  if (tagName.startsWith("deprecated/")) return { tagName, action: "skip", reason: "deprecated-tag", info: null };
-  const info = parseTreeseedDevTag(tagName, input.message);
-  if (!info) return { tagName, action: "skip", reason: input.message.includes("treeseed-dev-tag: true") ? "malformed-dev-tag" : "missing-treeseed-metadata", info: null };
-  if (input.expectedPackageName && info.packageName && info.packageName !== input.expectedPackageName) {
-    return { tagName, action: "skip", reason: "package-mismatch", info };
-  }
-  if ((input.activeReferences ?? []).includes(tagName)) return { tagName, action: "skip", reason: "still-referenced", info };
-  const scope = devTagScope(info);
-  if (scope === "main") return { tagName, action: "skip", reason: "main-or-production-tag", info };
-  const branchScope = input.branchScope ?? "all";
-  if (branchScope !== "all" && branchScope !== scope) return { tagName, action: "skip", reason: `scope-${scope}`, info };
-  const currentStableVersion = stableVersionBase(input.currentVersion);
-  if (!currentStableVersion) return { tagName, action: "skip", reason: "invalid-current-version", info };
-  const comparison = compareStableVersions(info.stableVersion, currentStableVersion);
-  if (comparison >= 0) {
-    return { tagName, action: "skip", reason: comparison === 0 ? "current-version" : "newer-version", info };
-  }
-  return { tagName, action: "delete", reason: "stale-before-current-version", info };
-}
-function cleanupDevTags(repoDir, tagNames, activeReferences = []) {
-  const active = new Set(activeReferences.filter(Boolean));
-  const cleaned = [];
-  const skipped = [];
-  for (const tagName of [...new Set(tagNames.filter(Boolean))].sort()) {
-    if (!tagName.includes("-dev.")) {
-      skipped.push({ tagName, reason: "not-dev-tag" });
-      continue;
-    }
-    if (active.has(tagName)) {
-      skipped.push({ tagName, reason: "still-referenced" });
-      continue;
-    }
-    if (!tagHasTreeseedDevMetadata(repoDir, tagName)) {
-      skipped.push({ tagName, reason: "missing-treeseed-metadata" });
-      continue;
-    }
-    try {
-      run("git", ["tag", "-d", tagName], { cwd: repoDir });
-      run("git", ["push", "origin", `:refs/tags/${tagName}`], { cwd: repoDir });
-      cleaned.push(tagName);
-    } catch (error) {
-      skipped.push({ tagName, reason: error instanceof Error ? error.message : String(error) });
+function collectDevelopmentCommitReferenceIssues(root = workspaceRoot(), packageNames = new Set(workspacePackages(root).map((pkg) => pkg.name))) {
+  const issues = [];
+  const manifestRoots = [
+    { name: "@treeseed/market", dir: root },
+    ...workspacePackages(root).map((pkg) => ({ name: pkg.name, dir: pkg.dir }))
+  ];
+  for (const pkg of manifestRoots) {
+    const packageJsonPath = resolve(pkg.dir, "package.json");
+    if (!existsSync(packageJsonPath)) continue;
+    const packageJson = readJson(packageJsonPath);
+    for (const field of internalDependencyFields(packageJson)) {
+      const values = packageJson[field];
+      for (const [depName, specValue] of Object.entries(values)) {
+        if (!packageNames.has(depName)) continue;
+        const spec = String(specValue);
+        if (!/^github:treeseed-ai\/[a-z0-9._-]+#[a-f0-9]{40}$/u.test(spec)) {
+          issues.push({
+            repoName: pkg.name,
+            filePath: packageJsonPath,
+            field,
+            dependencyName: depName,
+            spec,
+            reason: isGitDependencySpec(spec) ? "git-ref-is-not-commit-sha" : isPrereleaseVersion(spec) ? "prerelease-ref" : "non-git-commit-ref"
+          });
+        }
+      }
     }
   }
-  return { cleaned, skipped };
-}
-function localDevTags(repoDir) {
-  return run("git", ["tag", "-l", "*-dev.*"], { cwd: repoDir, capture: true }).split(/\r?\n/u).map((line) => line.trim()).filter(Boolean);
-}
-function remoteDevTags(repoDir) {
-  try {
-    return run("git", ["ls-remote", "--tags", "origin", "*-dev.*"], { cwd: repoDir, capture: true }).split(/\r?\n/u).map((line) => line.trim()).filter(Boolean).filter((line) => !line.endsWith("^{}")).map((line) => line.split(/\s+/u)[1] ?? "").filter((ref) => ref.startsWith("refs/tags/")).map((ref) => ref.slice("refs/tags/".length));
-  } catch {
-    return [];
+  for (const lockRoot of manifestRoots) {
+    for (const lockName of ["package-lock.json", "npm-shrinkwrap.json"]) {
+      const lockPath = resolve(lockRoot.dir, lockName);
+      if (!existsSync(lockPath)) continue;
+      const lockfile = readJson(lockPath);
+      const packageEntries = lockfile.packages && typeof lockfile.packages === "object" ? Object.entries(lockfile.packages) : [];
+      for (const [entryPath, entry] of packageEntries) {
+        if (!entry || typeof entry !== "object") continue;
+        for (const field of internalDependencyFields(entry)) {
+          const values = entry[field];
+          for (const [depName, specValue] of Object.entries(values)) {
+            if (!packageNames.has(depName)) continue;
+            const spec = String(specValue);
+            if (!/^github:treeseed-ai\/[a-z0-9._-]+#[a-f0-9]{40}$/u.test(spec)) {
+              issues.push({
+                repoName: lockRoot.name,
+                filePath: lockPath,
+                field: entryPath ? `packages.${entryPath}.${field}` : field,
+                dependencyName: depName,
+                spec,
+                reason: isGitDependencySpec(spec) ? "lockfile-git-ref-is-not-commit-sha" : "lockfile-non-git-commit-ref"
+              });
+            }
+          }
+        }
+      }
+    }
   }
+  return issues;
 }
-function collectTreeseedDevTagCleanupPlan(input) {
-  const tagNames = [.../* @__PURE__ */ new Set([...localDevTags(input.repoDir), ...remoteDevTags(input.repoDir)])].sort();
-  const classifications = tagNames.map((tagName) => classifyStaleTreeseedDevTag({
-    tagName,
-    message: gitDevTagMessage(input.repoDir, tagName),
-    currentVersion: input.currentVersion,
-    activeReferences: input.activeReferences ?? [],
-    branchScope: input.branchScope ?? "all",
-    expectedPackageName: input.packageName
-  }));
-  return {
-    packageName: input.packageName,
-    currentVersion: input.currentVersion,
-    branchScope: input.branchScope ?? "all",
-    candidates: classifications.filter((classification) => classification.action === "delete"),
-    skipped: classifications.filter((classification) => classification.action === "skip"),
-    tags: classifications
-  };
+function assertDevelopmentInternalCommitReferences(root = workspaceRoot(), packageNames) {
+  const issues = collectDevelopmentCommitReferenceIssues(root, packageNames);
+  if (issues.length === 0) return;
+  const rendered = issues.map((issue) => `${issue.filePath}${issue.field ? ` ${issue.field}.${issue.dependencyName}` : ""}: ${issue.reason} ${issue.spec}`).join("\n");
+  throw new Error(`Development and staging package references must use GitHub commit SHAs for internal Treeseed dependencies.
+${rendered}`);
 }
-function cleanupStaleTreeseedDevTags(input) {
-  const plan = collectTreeseedDevTagCleanupPlan(input);
-  const cleaned = [];
-  const skipped = [...plan.skipped.map((entry) => ({ tagName: entry.tagName, reason: entry.reason }))];
-  for (const candidate of plan.candidates) {
-    if (input.dryRun) continue;
-    try {
-      run("git", ["tag", "-d", candidate.tagName], { cwd: input.repoDir });
-    } catch {
-    }
-    try {
-      run("git", ["push", "origin", `:refs/tags/${candidate.tagName}`], { cwd: input.repoDir });
-      cleaned.push(candidate.tagName);
-    } catch (error) {
-      skipped.push({ tagName: candidate.tagName, reason: error instanceof Error ? error.message : String(error) });
-    }
-  }
-  return {
-    status: input.dryRun ? "planned" : "completed",
-    packageName: input.packageName,
-    currentVersion: input.currentVersion,
-    branchScope: input.branchScope ?? "all",
-    candidates: plan.candidates.map((entry) => ({ tagName: entry.tagName, reason: entry.reason, branch: entry.info?.branch, branchSlug: entry.info?.branchSlug, version: entry.info?.version })),
-    candidateCount: plan.candidates.length,
-    cleaned,
-    cleanedCount: cleaned.length,
-    skipped,
-    skippedCount: skipped.length
-  };
+function assertNoInternalDevReferences(root = workspaceRoot(), packageNames) {
+  const issues = collectInternalDevReferenceIssues(root, packageNames);
+  if (issues.length === 0) return;
+  const rendered = issues.map((issue) => `${issue.filePath}${issue.field ? ` ${issue.field}.${issue.dependencyName}` : ""}: ${issue.reason} ${issue.spec}`).join("\n");
+  throw new Error(`Stable release still contains internal Git or dev dependency references; production package.json files must use plain semver npm versions.
+${rendered}`);
 }
 export {
+  assertDevelopmentInternalCommitReferences,
   assertNoInternalDevReferences,
-  classifyStaleTreeseedDevTag,
-  cleanupDevTags,
-  cleanupStaleTreeseedDevTags,
+  collectDevelopmentCommitReferenceIssues,
   collectInternalDevReferenceIssues,
-  collectTreeseedDevTagCleanupPlan,
-  createDevTagMessage,
   createPackageDependencyReference,
   devTagFromDependencySpec,
-  gitTagMessage,
+  installableInternalDependencyVersions,
   internalDependencyFields,
   isGitDependencySpec,
   isPrereleaseVersion,
   isStableVersion,
   normalizeGitRemoteForDependency,
   normalizeGitRemoteForManifest,
-  parseTreeseedDevTag,
   releaseTagFromDependencySpec,
   rewriteInternalDependenciesToStableVersions,
   rewriteProjectInternalDependenciesToStableVersions,
-  tagHasTreeseedDevMetadata,
   updateInternalDependencySpecs
 };

package/dist/operations/services/project-host-operations.d.ts

@@ -1,7 +1,7 @@
-import type { ProjectEnvironmentName, ProjectLaunchHostBindingInput, TemplateLaunchRequirements } from '../../sdk-types.ts';
-import { type PlatformRepositoryDescriptor } from '../repository-operations.ts';
-import { type ProjectLaunchSecretSyncProgressEvent, type ProjectLaunchSecretSyncResult } from './template-secret-sync.ts';
-import { type ProjectLaunchHostInventoryRecord, type ProjectLaunchResolvedHostBinding, type ResolveProjectLaunchHostBindingsResult } from '../../template-launch-requirements.ts';
+import type { ProjectEnvironmentName, ProjectLaunchHostBindingInput, TemplateLaunchRequirements } from '../../sdk-types.js';
+import { type PlatformRepositoryDescriptor } from '../repository-operations.js';
+import { type ProjectLaunchSecretSyncProgressEvent, type ProjectLaunchSecretSyncResult } from './template-secret-sync.js';
+import { type ProjectLaunchHostInventoryRecord, type ProjectLaunchResolvedHostBinding, type ResolveProjectLaunchHostBindingsResult } from '../../template-launch-requirements.js';
 export type ProjectHostOperationKind = 'inspect' | 'audit' | 'resync' | 'replace' | 'rotate';
 export type ProjectHostOperationStatus = 'ok' | 'warning' | 'blocked';
 export interface ProjectHostOperationDiagnostic {