@ontrails/trails 1.0.0-beta.42 → 1.0.0-beta.43

package/src/release/check.ts

@@ -8,6 +8,8 @@ import { defaultReleaseConfig, releaseConfigSchema } from './config.js';
 import type { ReleaseConfigInput, ReleaseFactType } from './config.js';
 import { findPublicTrailContractChangeFacts } from './contract-facts.js';
 import type { ContractReleaseFact } from './contract-facts.js';
+import { findPackageRouteReleaseFacts } from './package-route-facts.js';
+import type { PackageRouteReleaseFact } from './package-route-facts.js';
 
 interface PackageJson {
   readonly name?: string;
@@ -23,6 +25,8 @@ export interface WorkspaceInfo {
 
 export interface ReleaseCheckInput {
   readonly baseRef?: string;
+  readonly baseWorkspaceError?: string;
+  readonly baseWorkspaces?: readonly WorkspaceInfo[];
   readonly changedFiles: readonly string[];
   readonly contractFacts?: readonly ContractReleaseFact[];
   readonly noReleaseOverride?: boolean;
@@ -42,6 +46,7 @@ export interface ReleaseCheckResult {
   readonly errors: readonly string[];
   readonly matchedRuleIds: readonly string[];
   readonly noReleaseOverride: boolean;
+  readonly packageRouteFacts: readonly PackageRouteReleaseFact[];
   readonly passed: boolean;
   /** Compatibility alias for the existing GitHub label and package script. */
   readonly releaseNone: boolean;
@@ -97,11 +102,21 @@ const VERSION_RELEASE_WORKSPACE_FILES = new Set([
   'package.json',
 ]);
 const normalizePath = (path: string): string =>
-  path.replaceAll('\\', '/').replace(/^\.\//u, '');
+  path.replaceAll('\\', '/').replace(/^\.\//u, '').replace(/\/+$/u, '');
+
+const normalizeWorkspacePattern = (pattern: string): string =>
+  normalizePath(pattern) || '.';
 
 const hasWorkspaceGlobSyntax = (pattern: string): boolean =>
   WORKSPACE_GLOB_SYNTAX_PATTERN.test(pattern);
 
+const isSupportedWorkspacePattern = (pattern: string): boolean =>
+  !hasWorkspaceGlobSyntax(pattern) ||
+  (pattern.endsWith('/*') && !hasWorkspaceGlobSyntax(pattern.slice(0, -2)));
+
+const unsupportedWorkspacePatternError = (pattern: string): string =>
+  `Unsupported workspace pattern '${pattern}'. The release check supports exact workspace paths and one-level '/*' globs.`;
+
 const readJson = async <T>(path: string): Promise<T> =>
   (await Bun.file(path).json()) as T;
 
@@ -112,6 +127,10 @@ const discoverWorkspaceDirs = async (
   const dirs: string[] = [];
 
   for (const pattern of patterns) {
+    if (!isSupportedWorkspacePattern(pattern)) {
+      throw new Error(unsupportedWorkspacePatternError(pattern));
+    }
+
     if (pattern.endsWith('/*')) {
       const parent = join(repoRoot, pattern.slice(0, -2));
       let names: string[] = [];
@@ -145,12 +164,6 @@ const discoverWorkspaceDirs = async (
       continue;
     }
 
-    if (hasWorkspaceGlobSyntax(pattern)) {
-      throw new Error(
-        `Unsupported workspace pattern '${pattern}'. The release check supports exact workspace paths and one-level '/*' globs.`
-      );
-    }
-
     throw new Error(
       `Workspace pattern '${pattern}' did not resolve to a package.json`
     );
@@ -190,6 +203,126 @@ export const discoverWorkspaces = async (
   );
 };
 
+interface BaseWorkspaceDiscovery {
+  readonly error?: string;
+  readonly workspaces: readonly WorkspaceInfo[];
+}
+
+const baseWorkspaceReadError = (baseRef: string): string =>
+  `Release check could not read the base workspace inventory from '${baseRef}'. Fetch or provide a valid --base-ref before checking package routes.`;
+
+const discoverBaseWorkspaces = (
+  repoRoot: string,
+  baseRef: string | undefined
+): BaseWorkspaceDiscovery => {
+  if (baseRef === undefined) {
+    return { workspaces: [] };
+  }
+
+  const root = Bun.spawnSync({
+    cmd: ['git', 'show', `${baseRef}:package.json`],
+    cwd: repoRoot,
+    stderr: 'pipe',
+    stdout: 'pipe',
+  });
+  if (root.exitCode !== 0) {
+    return { error: baseWorkspaceReadError(baseRef), workspaces: [] };
+  }
+  const workspacePatterns = (
+    JSON.parse(root.stdout.toString()) as PackageJson
+  ).workspaces?.map(normalizeWorkspacePattern);
+  if (!workspacePatterns || workspacePatterns.length === 0) {
+    return { workspaces: [] };
+  }
+  const unsupportedPattern = workspacePatterns.find(
+    (pattern) => !isSupportedWorkspacePattern(pattern)
+  );
+  if (unsupportedPattern) {
+    return {
+      error: unsupportedWorkspacePatternError(unsupportedPattern),
+      workspaces: [],
+    };
+  }
+
+  const listed = Bun.spawnSync({
+    cmd: ['git', 'ls-tree', '-r', '--name-only', baseRef],
+    cwd: repoRoot,
+    stderr: 'pipe',
+    stdout: 'pipe',
+  });
+  if (listed.exitCode !== 0) {
+    return { error: baseWorkspaceReadError(baseRef), workspaces: [] };
+  }
+
+  const workspaces: WorkspaceInfo[] = [];
+  for (const relativePath of listed.stdout.toString().split(/\r?\n/u)) {
+    if (
+      !relativePath.endsWith('/package.json') &&
+      relativePath !== 'package.json'
+    ) {
+      continue;
+    }
+    const workspacePath =
+      relativePath === 'package.json'
+        ? '.'
+        : normalizePath(relativePath.replace(/\/package\.json$/u, ''));
+    const isWorkspace = workspacePatterns.some(
+      (pattern) =>
+        pattern === workspacePath ||
+        (pattern.endsWith('/*') &&
+          workspacePath.startsWith(pattern.slice(0, -1)) &&
+          !workspacePath.slice(pattern.length - 1).includes('/'))
+    );
+    if (!isWorkspace) {
+      continue;
+    }
+    const shown = Bun.spawnSync({
+      cmd: ['git', 'show', `${baseRef}:${relativePath}`],
+      cwd: repoRoot,
+      stderr: 'pipe',
+      stdout: 'pipe',
+    });
+    if (shown.exitCode !== 0) {
+      return { error: baseWorkspaceReadError(baseRef), workspaces: [] };
+    }
+    const pkg = JSON.parse(shown.stdout.toString()) as PackageJson;
+    if (!pkg.name) {
+      continue;
+    }
+    workspaces.push({
+      isPrivate: pkg.private === true,
+      name: pkg.name,
+      relativePath: workspacePath,
+    });
+  }
+  return {
+    workspaces: workspaces.toSorted((left, right) =>
+      left.name.localeCompare(right.name)
+    ),
+  };
+};
+
+const resolveBaseWorkspaceInput = (
+  input: ReleaseCheckInput
+): BaseWorkspaceDiscovery => {
+  if (input.baseWorkspaces !== undefined) {
+    return {
+      ...(input.baseWorkspaceError === undefined
+        ? {}
+        : { error: input.baseWorkspaceError }),
+      workspaces: input.baseWorkspaces,
+    };
+  }
+
+  const discovered = discoverBaseWorkspaces(input.repoRoot, input.baseRef);
+  const error = input.baseWorkspaceError ?? discovered.error;
+
+  return {
+    ...(error === undefined ? {} : { error }),
+    workspaces: discovered.workspaces,
+  };
+};
+
 const isPublishableOnTrailsWorkspace = (workspace: WorkspaceInfo): boolean =>
   !workspace.isPrivate && workspace.name.startsWith('@ontrails/');
 
@@ -303,6 +436,84 @@ const parseChangesetPackages = (content: string): readonly string[] => {
   });
 };
 
+const readBaseChangeset = (
+  repoRoot: string,
+  baseRef: string | undefined,
+  path: string
+): string | null => {
+  if (baseRef === undefined) {
+    return null;
+  }
+
+  const result = Bun.spawnSync({
+    cmd: ['git', 'show', `${baseRef}:${path}`],
+    cwd: repoRoot,
+    stderr: 'pipe',
+    stdout: 'pipe',
+  });
+
+  return result.exitCode === 0 ? result.stdout.toString() : null;
+};
+
+const removeChangesetPackageRows = (
+  content: string,
+  packages: ReadonlySet<string>
+): string => {
+  let insideFrontmatter = false;
+
+  return content
+    .split('\n')
+    .filter((line, index) => {
+      const normalizedLine = line.replace(/\r$/u, '');
+
+      if (normalizedLine === '---') {
+        insideFrontmatter = index === 0;
+        return true;
+      }
+
+      if (!insideFrontmatter) {
+        return true;
+      }
+
+      const packageName = normalizedLine.match(CHANGESET_PACKAGE_PATTERN)?.[1];
+      return packageName === undefined || !packages.has(packageName);
+    })
+    .join('\n');
+};
+
+const findRetiredPackageChangesetCleanups = (
+  changedChangesetPaths: readonly string[],
+  input: ReleaseCheckInput
+): readonly string[] => {
+  const workspaceNames = new Set(
+    input.workspaces.map((workspace) => workspace.name)
+  );
+
+  return changedChangesetPaths.filter((path) => {
+    const absolutePath = join(input.repoRoot, path);
+    if (!existsSync(absolutePath)) {
+      return false;
+    }
+
+    const baseContent = readBaseChangeset(input.repoRoot, input.baseRef, path);
+    if (baseContent === null) {
+      return false;
+    }
+
+    const retiredPackages = new Set(
+      parseChangesetPackages(baseContent).filter(
+        (packageName) => !workspaceNames.has(packageName)
+      )
+    );
+
+    return (
+      retiredPackages.size > 0 &&
+      removeChangesetPackageRows(baseContent, retiredPackages) ===
+        readFileSync(absolutePath, 'utf8')
+    );
+  });
+};
+
 const findChangedChangesetPaths = (
   changedFiles: readonly string[]
 ): readonly string[] =>
@@ -380,9 +591,45 @@ const findMatchedRuleIds = (input: ReleaseCheckInput): readonly string[] => {
     .toSorted();
 };
 
+const findPackageRouteRuleErrors = ({
+  coveredPackages,
+  packageRoute,
+  requiresPackageRoute,
+}: {
+  readonly coveredPackages: readonly string[];
+  readonly packageRoute: ReturnType<typeof findPackageRouteReleaseFacts>;
+  readonly requiresPackageRoute: boolean;
+}): readonly string[] => {
+  if (!requiresPackageRoute) {
+    return [];
+  }
+
+  const errors = packageRoute.diagnostics.map(
+    (diagnostic) => diagnostic.message
+  );
+
+  const uncoveredIntents = packageRoute.intents.filter(
+    (intent) =>
+      !intent.eligiblePackages.some((packageName) =>
+        coveredPackages.includes(packageName)
+      )
+  );
+
+  if (uncoveredIntents.length > 0) {
+    errors.push(
+      `Public package route changesets must cover a surviving owner: ${uncoveredIntents
+        .map((intent) => intent.sourcePackage)
+        .join(', ')}`
+    );
+  }
+
+  return errors;
+};
+
 export const checkReleaseRules = (
   input: ReleaseCheckInput
 ): ReleaseCheckResult => {
+  const baseWorkspaceInput = resolveBaseWorkspaceInput(input);
   const noReleaseOverride =
     input.noReleaseOverride === true || input.releaseNone === true;
   const affectedPackages = findAffectedPackages(
@@ -394,11 +641,18 @@ export const checkReleaseRules = (
     input.changedFiles,
     input.repoRoot
   );
+  const retiredPackageChangesetCleanups = new Set(
+    findRetiredPackageChangesetCleanups(changedChangesets, input)
+  );
   const changesets = findChangedChangesets(changedChangesets, input.repoRoot);
   const coveredPackages = [
     ...new Set(changesets.flatMap((changeset) => changeset.packages)),
   ].toSorted();
   const contractFacts = findGateContractFacts(input);
+  const packageRoute = findPackageRouteReleaseFacts({
+    baseWorkspaces: baseWorkspaceInput.workspaces,
+    workspaces: input.workspaces,
+  });
   const versionRelease = isVersionReleaseChangeSet(
     input.changedFiles,
     input.workspaces,
@@ -411,10 +665,15 @@ export const checkReleaseRules = (
     (fact) => !isContractFactCovered(fact, coveredPackages)
   );
   const hasReleaseFacts =
-    affectedPackages.length > 0 || contractFacts.length > 0 || versionRelease;
+    affectedPackages.length > 0 ||
+    contractFacts.length > 0 ||
+    packageRoute.facts.length > 0 ||
+    versionRelease;
   const activePackageChangesetsWithoutReleaseFacts =
     activeChangedChangesets.length > 0 && !hasReleaseFacts
-      ? activeChangedChangesets
+      ? activeChangedChangesets.filter(
+          (path) => !retiredPackageChangesetCleanups.has(path)
+        )
       : [];
   const matchedRuleIds = findMatchedRuleIds(input);
   const requiresPackageIntent = ruleMatchesFactType(input, 'package-content');
@@ -422,8 +681,16 @@ export const checkReleaseRules = (
     input,
     'public-trail-contract'
   );
+  const requiresPackageRoute = ruleMatchesFactType(
+    input,
+    'public-package-route'
+  );
   const errors: string[] = [];
 
+  if (baseWorkspaceInput.error) {
+    errors.push(baseWorkspaceInput.error);
+  }
+
   if (noReleaseOverride && changedChangesets.length > 0) {
     errors.push(
       '`release:none` conflicts with changed changeset files. Remove the label or the changeset.'
@@ -447,6 +714,14 @@ export const checkReleaseRules = (
     );
   }
 
+  errors.push(
+    ...findPackageRouteRuleErrors({
+      coveredPackages,
+      packageRoute,
+      requiresPackageRoute,
+    })
+  );
+
   if (
     !noReleaseOverride &&
     !versionRelease &&
@@ -469,6 +744,7 @@ export const checkReleaseRules = (
     errors,
     matchedRuleIds,
     noReleaseOverride,
+    packageRouteFacts: packageRoute.facts,
     passed: errors.length === 0,
     releaseNone: noReleaseOverride,
     uncoveredContractFacts,
@@ -516,6 +792,17 @@ const readLocalChangedFiles = (
   return parseChangedFilesOutput(result.stdout.toString());
 };
 
+const hasGitRef = (repoRoot: string, ref: string): boolean => {
+  const result = Bun.spawnSync({
+    cmd: ['git', 'rev-parse', '--verify', '--quiet', `${ref}^{commit}`],
+    cwd: repoRoot,
+    stderr: 'pipe',
+    stdout: 'pipe',
+  });
+
+  return result.exitCode === 0;
+};
+
 const isRecord = (value: unknown): value is Record<string, unknown> =>
   typeof value === 'object' && value !== null;
 
@@ -769,9 +1056,16 @@ export const runReleaseCheck = async (
   options: RunReleaseCheckOptions
 ): Promise<ReleaseCheckReport> => {
   const workspaces = await discoverWorkspaces(options.repoRoot);
+  const changedFilesBaseError =
+    options.changedFilesPath !== undefined && options.baseRef === undefined
+      ? 'Release check requires --base-ref when --changed-files is used.'
+      : undefined;
   const baseRef =
     options.baseRef ??
-    (options.changedFilesPath === undefined ? 'origin/main' : undefined);
+    (options.changedFilesPath === undefined &&
+    (workspaces.length > 0 || hasGitRef(options.repoRoot, 'origin/main'))
+      ? 'origin/main'
+      : undefined);
   let changedFiles: readonly string[];
 
   if (options.changedFilesPath !== undefined) {
@@ -792,8 +1086,16 @@ export const runReleaseCheck = async (
     env: options.env,
     repoRoot: options.repoRoot,
   });
+  const baseWorkspaceDiscovery = discoverBaseWorkspaces(
+    options.repoRoot,
+    baseRef
+  );
+  const baseWorkspaceError =
+    changedFilesBaseError ?? baseWorkspaceDiscovery.error;
   const result = checkReleaseRules({
     ...(baseRef === undefined ? {} : { baseRef }),
+    ...(baseWorkspaceError === undefined ? {} : { baseWorkspaceError }),
+    baseWorkspaces: baseWorkspaceDiscovery.workspaces,
     changedFiles,
     ...(loadedConfig.config === undefined
       ? {}

package/src/release/config.ts

@@ -2,6 +2,7 @@ import { z } from 'zod';
 
 export const releaseFactTypeValues = [
   'package-content',
+  'public-package-route',
   'public-trail-contract',
 ] as const;
 
@@ -31,6 +32,15 @@ export type ReleaseRule = z.output<typeof releaseRuleSchema>;
 export type ReleaseRuleInput = z.input<typeof releaseRuleSchema>;
 
 export const defaultReleaseRules = [
+  {
+    description:
+      'Public package removals require an exact governed Regrade route or classified multi-owner fold plus branch-local release intent.',
+    enabled: true,
+    facts: ['public-package-route'],
+    id: 'public-package-route-requires-regrade',
+    intent: ['changeset'],
+    severity: 'error',
+  },
   {
     description:
       'Publishable package content changes require positive release intent.',

package/src/release/index.ts

@@ -31,6 +31,11 @@ export {
   type ContractReleaseFactInput,
   type ContractSourceSnapshot,
 } from './contract-facts.js';
+export {
+  findPackageRouteReleaseFacts,
+  type PackageRouteReleaseDiagnostic,
+  type PackageRouteReleaseFact,
+} from './package-route-facts.js';
 export {
   defaultReleaseConfig,
   defaultReleaseRules,

package/src/release/package-route-facts.ts

@@ -0,0 +1,146 @@
+import { listGovernedVocabularyTransitions } from '@ontrails/warden';
+
+import type { WorkspaceInfo } from './check.js';
+
+export interface PackageRouteReleaseFact {
+  readonly kind: 'classified' | 'single';
+  readonly sourcePackage: string;
+  readonly targetPackage?: string;
+  readonly transitionId: string;
+}
+
+export interface PackageRouteReleaseDiagnostic {
+  readonly code:
+    | 'missing-governed-package-route'
+    | 'missing-governed-package-route-target';
+  readonly message: string;
+  readonly sourcePackage: string;
+}
+
+export interface PackageRouteReleaseIntent {
+  readonly eligiblePackages: readonly string[];
+  readonly sourcePackage: string;
+}
+
+const isPublishableTrailsPackage = (workspace: WorkspaceInfo): boolean =>
+  !workspace.isPrivate && workspace.name.startsWith('@ontrails/');
+
+const findPackageRouteTransition = (
+  transitions: ReturnType<typeof listGovernedVocabularyTransitions>,
+  sourcePackage: string
+) => {
+  const direct = transitions.find(
+    (transition) => transition.from === sourcePackage
+  );
+
+  if (direct) {
+    return { target: direct.target, transition: direct };
+  }
+
+  for (const transition of transitions) {
+    const moduleSpecifierRoute = transition.stringLiteralRenames.find(
+      (route) =>
+        route.from === sourcePackage &&
+        route.moduleSpecifier?.targetPackage !== undefined
+    );
+
+    if (moduleSpecifierRoute?.moduleSpecifier?.targetPackage) {
+      return {
+        target: {
+          kind: 'single' as const,
+          to: moduleSpecifierRoute.moduleSpecifier.targetPackage,
+        },
+        transition,
+      };
+    }
+  }
+
+  return null;
+};
+
+export const findPackageRouteReleaseFacts = ({
+  baseWorkspaces,
+  workspaces,
+}: {
+  readonly baseWorkspaces: readonly WorkspaceInfo[];
+  readonly workspaces: readonly WorkspaceInfo[];
+}): {
+  readonly diagnostics: readonly PackageRouteReleaseDiagnostic[];
+  readonly facts: readonly PackageRouteReleaseFact[];
+  readonly intents: readonly PackageRouteReleaseIntent[];
+} => {
+  const currentPackages = new Set(
+    workspaces
+      .filter(isPublishableTrailsPackage)
+      .map((workspace) => workspace.name)
+  );
+  const removedPackages = baseWorkspaces
+    .filter(isPublishableTrailsPackage)
+    .map((workspace) => workspace.name)
+    .filter((name) => !currentPackages.has(name))
+    .toSorted();
+  const transitions = listGovernedVocabularyTransitions();
+  const diagnostics: PackageRouteReleaseDiagnostic[] = [];
+  const facts: PackageRouteReleaseFact[] = [];
+  const intents: PackageRouteReleaseIntent[] = [];
+
+  for (const sourcePackage of removedPackages) {
+    const resolvedRoute = findPackageRouteTransition(
+      transitions,
+      sourcePackage
+    );
+
+    if (!resolvedRoute) {
+      diagnostics.push({
+        code: 'missing-governed-package-route',
+        message: `Public package removal '${sourcePackage}' requires an exact governed Regrade route. Add the route to the governed transition registry, then run trails regrade plan/check.`,
+        sourcePackage,
+      });
+      continue;
+    }
+
+    const { target, transition } = resolvedRoute;
+
+    if (target.kind === 'classified') {
+      const classifiedTarget = target;
+      const eligiblePackages = [...currentPackages]
+        .filter((packageName) =>
+          classifiedTarget.options.some(
+            (option) =>
+              option.to === packageName ||
+              option.to.startsWith(`${packageName}/`)
+          )
+        )
+        .toSorted();
+      facts.push({
+        kind: 'classified',
+        sourcePackage,
+        transitionId: transition.id,
+      });
+      intents.push({ eligiblePackages, sourcePackage });
+      continue;
+    }
+
+    if (!currentPackages.has(target.to)) {
+      diagnostics.push({
+        code: 'missing-governed-package-route-target',
+        message: `Governed Regrade route '${transition.id}' maps '${sourcePackage}' to '${target.to}', but that publishable target package is absent. Add the target package before applying the route, or use a classified transition with an explicit non-migratable reason for a multi-owner fold.`,
+        sourcePackage,
+      });
+      continue;
+    }
+
+    facts.push({
+      kind: 'single',
+      sourcePackage,
+      targetPackage: target.to,
+      transitionId: transition.id,
+    });
+    intents.push({
+      eligiblePackages: [target.to],
+      sourcePackage,
+    });
+  }
+
+  return { diagnostics, facts, intents };
+};

package/src/run-completions-install.ts

@@ -12,7 +12,7 @@ import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 
 import {
-  projectPublicSurfaceError,
+  renderPublicSurfaceError,
   Result,
   ValidationError,
 } from '@ontrails/core';
@@ -138,9 +138,9 @@ export const runCompletionsInstall = async (
 
 const handleCliError = (error: unknown): void => {
   const err = error instanceof Error ? error : new Error(String(error));
-  const projection = projectPublicSurfaceError('cli', err);
-  process.stderr.write(`Error: ${projection.message}\n`);
-  process.exit(projection.code);
+  const rendering = renderPublicSurfaceError('cli', err);
+  process.stderr.write(`Error: ${rendering.message}\n`);
+  process.exit(rendering.code);
 };
 
 const findCompletionsCommand = (program: Command): Command | undefined =>

package/src/run-trace.ts

@@ -5,7 +5,7 @@
  * intrinsic tracing pipeline in `@ontrails/core` records every trail-,
  * span-, signal-, and activation-level event during the invocation. After
  * the trail completes (success or failure), the records are rendered as a
- * tree to stderr via `renderTraceTree` from `@ontrails/observe`. Under
+ * tree to stderr via `renderTraceTree` from `@ontrails/observability`. Under
  * `--json`, the structured `TraceRecord[]` is also emitted on stdout as
  * the `tracing` field of a Result envelope.
  *
@@ -25,8 +25,8 @@
 
 import { getTraceSink, registerTraceSink } from '@ontrails/core';
 import type { TraceRecord, TraceSink } from '@ontrails/core';
-import { createMemorySink, renderTraceTree } from '@ontrails/observe';
-import type { MemoryTraceSink } from '@ontrails/observe';
+import { createMemorySink, renderTraceTree } from '@ontrails/observability';
+import type { MemoryTraceSink } from '@ontrails/observability';
 
 // ---------------------------------------------------------------------------
 // Argv detection
@@ -166,7 +166,7 @@ const errorFromUnknown = (
  * On success, the inner value is taken straight from the trail's
  * `Result.ok(...)` payload. On failure the envelope captures the error's
  * `name` and `message` -- both safe to serialize and consistent with how
- * other Trails surfaces project errors.
+ * other Trails surfaces render errors.
  */
 export const buildTraceJsonEnvelope = (
   result: ResultLike,

package/src/trails/dev-support.ts

@@ -18,7 +18,7 @@ import {
   applyTraceCleanup,
   countTraceRecords,
   previewTraceCleanup,
-} from '@ontrails/tracing';
+} from '@ontrails/observability/dev';
 
 import {
   removeFileIfPresent,