@shipfox/client-shell 0.2.0

package/test/external/toy-feature/node_modules/.bin/shipfox-swc

@@ -0,0 +1,43 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+basedir_win="$basedir"
+exe=""
+msys=""
+
+case `uname -a` in
+  *CYGWIN*|*MINGW*|*MSYS*)
+    if command -v cygpath > /dev/null 2>&1; then
+      basedir_win=`cygpath -w "$basedir"`
+    fi
+    exe=".exe"
+    msys="true"
+  ;;
+  *WSL2*)
+    if command -v wslpath > /dev/null 2>&1; then
+      basedir_win="$(wslpath -w "$basedir" 2> /dev/null)"
+      if [ $? -ne 0 ] || [ -z "$basedir_win" ]; then
+        basedir_win="$basedir"
+      else
+        exe=".exe"
+      fi
+    fi
+  ;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/Users/noe.charmet/conductor/workspaces/platform-v1/singapore/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/Users/noe.charmet/conductor/workspaces/platform-v1/singapore/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -n "$exe" ] && [ -x "$basedir/node.exe" ]; then
+  exec "$basedir/node.exe"  "$basedir_win/../@shipfox/swc/bin/swc.js" "$@"
+elif [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../@shipfox/swc/bin/swc.js" "$@"
+elif command -v node >/dev/null 2>&1; then
+  exec node  "$basedir/../@shipfox/swc/bin/swc.js" "$@"
+elif [ -n "$exe" ] && command -v node.exe >/dev/null 2>&1; then
+  exec node.exe  "$basedir_win/../@shipfox/swc/bin/swc.js" "$@"
+else
+  exec node  "$basedir/../@shipfox/swc/bin/swc.js" "$@"
+fi
+# cmd-shim-target=/Users/noe.charmet/conductor/workspaces/platform-v1/singapore/libs/client/shell/test/external/toy-feature/node_modules/@shipfox/swc/bin/swc.js

package/test/external/toy-feature/node_modules/.bin/shipfox-tsc-check

@@ -0,0 +1,43 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+basedir_win="$basedir"
+exe=""
+msys=""
+
+case `uname -a` in
+  *CYGWIN*|*MINGW*|*MSYS*)
+    if command -v cygpath > /dev/null 2>&1; then
+      basedir_win=`cygpath -w "$basedir"`
+    fi
+    exe=".exe"
+    msys="true"
+  ;;
+  *WSL2*)
+    if command -v wslpath > /dev/null 2>&1; then
+      basedir_win="$(wslpath -w "$basedir" 2> /dev/null)"
+      if [ $? -ne 0 ] || [ -z "$basedir_win" ]; then
+        basedir_win="$basedir"
+      else
+        exe=".exe"
+      fi
+    fi
+  ;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/Users/noe.charmet/conductor/workspaces/platform-v1/singapore/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/Users/noe.charmet/conductor/workspaces/platform-v1/singapore/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -n "$exe" ] && [ -x "$basedir/node.exe" ]; then
+  exec "$basedir/node.exe"  "$basedir_win/../@shipfox/typescript/bin/tsc-check.js" "$@"
+elif [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../@shipfox/typescript/bin/tsc-check.js" "$@"
+elif command -v node >/dev/null 2>&1; then
+  exec node  "$basedir/../@shipfox/typescript/bin/tsc-check.js" "$@"
+elif [ -n "$exe" ] && command -v node.exe >/dev/null 2>&1; then
+  exec node.exe  "$basedir_win/../@shipfox/typescript/bin/tsc-check.js" "$@"
+else
+  exec node  "$basedir/../@shipfox/typescript/bin/tsc-check.js" "$@"
+fi
+# cmd-shim-target=/Users/noe.charmet/conductor/workspaces/platform-v1/singapore/libs/client/shell/test/external/toy-feature/node_modules/@shipfox/typescript/bin/tsc-check.js

package/test/external/toy-feature/node_modules/.bin/shipfox-tsc-emit

@@ -0,0 +1,43 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+basedir_win="$basedir"
+exe=""
+msys=""
+
+case `uname -a` in
+  *CYGWIN*|*MINGW*|*MSYS*)
+    if command -v cygpath > /dev/null 2>&1; then
+      basedir_win=`cygpath -w "$basedir"`
+    fi
+    exe=".exe"
+    msys="true"
+  ;;
+  *WSL2*)
+    if command -v wslpath > /dev/null 2>&1; then
+      basedir_win="$(wslpath -w "$basedir" 2> /dev/null)"
+      if [ $? -ne 0 ] || [ -z "$basedir_win" ]; then
+        basedir_win="$basedir"
+      else
+        exe=".exe"
+      fi
+    fi
+  ;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/Users/noe.charmet/conductor/workspaces/platform-v1/singapore/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/Users/noe.charmet/conductor/workspaces/platform-v1/singapore/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -n "$exe" ] && [ -x "$basedir/node.exe" ]; then
+  exec "$basedir/node.exe"  "$basedir_win/../@shipfox/typescript/bin/tsc-emit.js" "$@"
+elif [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../@shipfox/typescript/bin/tsc-emit.js" "$@"
+elif command -v node >/dev/null 2>&1; then
+  exec node  "$basedir/../@shipfox/typescript/bin/tsc-emit.js" "$@"
+elif [ -n "$exe" ] && command -v node.exe >/dev/null 2>&1; then
+  exec node.exe  "$basedir_win/../@shipfox/typescript/bin/tsc-emit.js" "$@"
+else
+  exec node  "$basedir/../@shipfox/typescript/bin/tsc-emit.js" "$@"
+fi
+# cmd-shim-target=/Users/noe.charmet/conductor/workspaces/platform-v1/singapore/libs/client/shell/test/external/toy-feature/node_modules/@shipfox/typescript/bin/tsc-emit.js

package/test/external/toy-feature/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@shipfox/client-shell-fixture-feature",
+  "version": "0.0.3",
+  "private": true,
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "development": {
+        "types": "./src/index.ts",
+        "default": "./src/index.ts"
+      },
+      "default": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./routes/*": {
+      "development": {
+        "types": "./src/routes/*.tsx",
+        "default": "./src/routes/*.tsx"
+      },
+      "default": {
+        "types": "./dist/routes/*.d.ts",
+        "default": "./dist/routes/*.js"
+      }
+    }
+  },
+  "scripts": {
+    "build": "shipfox-swc",
+    "check": "shipfox-biome-check",
+    "check:fix": "shipfox-biome-check --write",
+    "type": "shipfox-tsc-check",
+    "type:emit": "shipfox-tsc-emit"
+  },
+  "dependencies": {
+    "@shipfox/client-shell": "workspace:*",
+    "@swc/helpers": "catalog:",
+    "zod": "catalog:"
+  },
+  "peerDependencies": {
+    "@tanstack/react-query": "^5.101.0",
+    "@tanstack/react-router": "^1.170.16",
+    "react": "^19.0.0"
+  },
+  "devDependencies": {
+    "@shipfox/biome": "workspace:*",
+    "@shipfox/swc": "workspace:*",
+    "@shipfox/ts-config": "workspace:*",
+    "@shipfox/typescript": "workspace:*",
+    "@tanstack/react-query": "catalog:",
+    "@tanstack/react-router": "catalog:",
+    "@types/react": "catalog:",
+    "react": "catalog:"
+  }
+}

package/test/external/toy-feature/src/config.ts

@@ -0,0 +1,5 @@
+import {z} from 'zod';
+
+export const toyConfigShape = {
+  fixtureGreeting: z.string().min(1).describe('Greeting required by the external fixture feature.'),
+};

package/test/external/toy-feature/src/index.ts

@@ -0,0 +1,64 @@
+import {defineClientFeature} from '@shipfox/client-shell';
+import {toyConfigShape} from './config.js';
+import {ToyFeatureProvider} from './provider.js';
+
+export {
+  ProviderProbe,
+  type ProviderProbeEntry,
+  ProviderProbeObserver,
+} from './provider.js';
+
+export const toyFeature = defineClientFeature({
+  id: 'fixture.toy-feature',
+  routes: [
+    {
+      path: '/workspaces/$wid/insights',
+      parent: 'workspaceLayout',
+      impl: '@shipfox/client-shell-fixture-feature/routes/insights',
+    },
+    {
+      path: '/workspaces/$wid/settings/primary',
+      parent: 'workspaceSettings',
+      impl: '@shipfox/client-shell-fixture-feature/routes/settings',
+    },
+    {
+      path: '/workspaces/$wid/settings/secondary',
+      parent: 'workspaceSettings',
+      impl: '@shipfox/client-shell-fixture-feature/routes/settings',
+    },
+  ],
+  providers: [{id: 'fixture-toy-provider', Component: ToyFeatureProvider}],
+  navigation: [
+    {
+      id: 'fixture-insights-first',
+      scope: 'workspace',
+      label: 'Insights first',
+      to: '/workspaces/$wid/insights',
+      order: 100,
+    },
+    {
+      id: 'fixture-insights-second',
+      scope: 'workspace',
+      label: 'Insights second',
+      to: '/workspaces/$wid/insights',
+      order: 200,
+    },
+  ],
+  settingsSections: [
+    {
+      id: 'fixture-primary-settings',
+      pathSegment: 'primary',
+      label: 'Primary settings',
+      icon: 'userLine',
+      order: 100,
+    },
+    {
+      id: 'fixture-secondary-settings',
+      pathSegment: 'secondary',
+      label: 'Secondary settings',
+      icon: 'settings3Line',
+      order: 200,
+    },
+  ],
+  configShape: toyConfigShape,
+});

package/test/external/toy-feature/src/provider.tsx

@@ -0,0 +1,33 @@
+import {type QueryClient, useQueryClient} from '@tanstack/react-query';
+import {createContext, type PropsWithChildren, useContext, useEffect, useMemo} from 'react';
+
+export interface ProviderProbeEntry {
+  id: string;
+  queryClient: QueryClient;
+}
+
+const ProviderProbeContext = createContext<readonly ProviderProbeEntry[]>([]);
+
+export function ProviderProbe({id, children}: PropsWithChildren<{id: string}>) {
+  const parentEntries = useContext(ProviderProbeContext);
+  const queryClient = useQueryClient();
+  const entries = useMemo(
+    () => [...parentEntries, {id, queryClient}],
+    [id, parentEntries, queryClient],
+  );
+  return <ProviderProbeContext value={entries}>{children}</ProviderProbeContext>;
+}
+
+export function ProviderProbeObserver({
+  onChange,
+}: {
+  onChange: (entries: readonly ProviderProbeEntry[]) => void;
+}) {
+  const entries = useContext(ProviderProbeContext);
+  useEffect(() => onChange(entries), [entries, onChange]);
+  return null;
+}
+
+export function ToyFeatureProvider({children}: PropsWithChildren) {
+  return <ProviderProbe id="toy-feature">{children}</ProviderProbe>;
+}

package/test/external/toy-feature/src/routes/insights.tsx

@@ -0,0 +1,7 @@
+import {defineRoute} from '@shipfox/client-shell/runtime';
+
+function ToyInsights() {
+  return <h1>Toy insights</h1>;
+}
+
+export default defineRoute({component: ToyInsights});

package/test/external/toy-feature/src/routes/settings.tsx

@@ -0,0 +1,7 @@
+import {defineRoute} from '@shipfox/client-shell/runtime';
+
+function ToySettings() {
+  return <h1>Toy settings</h1>;
+}
+
+export default defineRoute({component: ToySettings});

package/test/external/toy-feature/tsconfig.build.json

@@ -0,0 +1,5 @@
+{
+  "extends": "@shipfox/ts-config/react",
+  "compilerOptions": { "rootDir": "src", "outDir": "dist" },
+  "include": ["src"]
+}

package/test/external/toy-feature/tsconfig.json

@@ -0,0 +1 @@
+{ "files": [], "references": [{ "path": "tsconfig.build.json" }] }

package/test/external/verify.mjs

@@ -0,0 +1,318 @@
+import {spawn} from 'node:child_process';
+import {globSync} from 'node:fs';
+import {cp, mkdir, mkdtemp, readdir, readFile, realpath, rm, writeFile} from 'node:fs/promises';
+import {tmpdir} from 'node:os';
+import {basename, join, relative, resolve, sep} from 'node:path';
+import {fileURLToPath, pathToFileURL} from 'node:url';
+
+const repositoryRoot = resolve(fileURLToPath(new URL('../../../../..', import.meta.url)));
+const externalRoot = fileURLToPath(new URL('.', import.meta.url));
+const fixtureTemplate = join(externalRoot, 'fixture');
+const REGISTRY_SHIPFOX_PACKAGE_PATTERN = /^@shipfox\+[^@]+@\d/u;
+const linkMode = process.argv.includes('--link');
+
+if (process.argv.some((argument) => argument.startsWith('--') && argument !== '--link')) {
+  throw new Error('Usage: node verify.mjs [--link]');
+}
+
+const {
+  computePublicationClosure,
+  entryPointSupportsRuntimeImport,
+  entryPointSupportsTypeResolution,
+  listPublicPackageEntryPoints,
+  readPublicationClosureConfig,
+  readWorkspacePackages,
+  validatePublicationState,
+} = await import(
+  pathToFileURL(join(repositoryRoot, 'tools/application-release/dist/package-closure.js')).href
+);
+const config = readPublicationClosureConfig(join(repositoryRoot, 'publication-closure.json'));
+const workspacePackages = readWorkspacePackages(repositoryRoot);
+validatePublicationState(workspacePackages, config, repositoryRoot);
+const clientRoots = config.roots.filter((root) => root.startsWith('@shipfox/client-'));
+const closure = computePublicationClosure(workspacePackages, clientRoots);
+const entryPoints = closure.flatMap((name) =>
+  listConcreteEntryPoints(name, requiredPackage(workspacePackages, name)),
+);
+const runtimeEntryPoints = entryPoints
+  .filter(({target}) => entryPointSupportsRuntimeImport(target))
+  .map(({specifier}) => specifier);
+const typeEntryPoints = entryPoints
+  .filter(({target}) => entryPointSupportsTypeResolution(target))
+  .map(({specifier}) => specifier);
+const temporaryRoot = await mkdtemp(join(tmpdir(), 'shipfox-client-composition-'));
+const fixtureRoot = join(temporaryRoot, 'fixture');
+
+try {
+  await cp(fixtureTemplate, fixtureRoot, {recursive: true});
+  const packageSpecs = linkMode
+    ? linkedPackageSpecs(closure, workspacePackages)
+    : await packedPackageSpecs(closure, workspacePackages, temporaryRoot);
+  await configureFixture(fixtureRoot, packageSpecs);
+  await writeTypeFixture(fixtureRoot, typeEntryPoints);
+  await run('pnpm', ['install', '--prefer-offline', '--ignore-scripts'], fixtureRoot);
+
+  if (linkMode) await validateLinkedPackages(fixtureRoot, closure, workspacePackages);
+  else {
+    await validateInstalledPackages(fixtureRoot, closure, workspacePackages);
+    await validateNoRegistryShipfoxPackages(fixtureRoot);
+    await validateDefaultPackageResolution(fixtureRoot, runtimeEntryPoints);
+  }
+
+  await run('pnpm', ['exec', 'vite', 'build'], fixtureRoot);
+  await run('pnpm', ['exec', 'tsc', '--noEmit'], fixtureRoot);
+
+  process.stdout.write(
+    `Verified ${closure.length} external client runtime packages and ${entryPoints.length} public entry points in ${linkMode ? 'linked' : 'packed-tarball'} mode.\n`,
+  );
+} finally {
+  await rm(temporaryRoot, {recursive: true, force: true});
+}
+
+function linkedPackageSpecs(names, packages) {
+  return Object.fromEntries(
+    names.map((name) => {
+      const workspacePackage = requiredPackage(packages, name);
+      return [name, `link:${workspacePackage.directory}`];
+    }),
+  );
+}
+
+async function packedPackageSpecs(names, packages, root) {
+  const tarballRoot = join(root, 'tarballs');
+  await mkdir(tarballRoot);
+  const tarballs = await mapWithConcurrency(names, 4, async (name) => {
+    const workspacePackage = requiredPackage(packages, name);
+    const tarball = join(tarballRoot, `${safePackageName(name)}.tgz`);
+    await run('pnpm', ['pack', '--out', tarball], workspacePackage.directory, {capture: true});
+    return [name, `file:${tarball}`];
+  });
+  return Object.fromEntries(tarballs);
+}
+
+async function configureFixture(root, packageSpecs) {
+  const manifestPath = join(root, 'package.json');
+  const manifest = JSON.parse(await readFile(manifestPath, 'utf8'));
+  manifest.dependencies = {...manifest.dependencies, ...packageSpecs};
+  await Promise.all([
+    writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`),
+    writeFile(
+      join(root, 'pnpm-workspace.yaml'),
+      `packages:\n  - .\noverrides:\n${Object.entries(packageSpecs)
+        .map(([name, specifier]) => `  ${JSON.stringify(name)}: ${JSON.stringify(specifier)}`)
+        .join('\n')}\n`,
+    ),
+  ]);
+}
+
+async function writeTypeFixture(root, entryPoints) {
+  await writeFile(
+    join(root, 'types.ts'),
+    `${entryPoints
+      .map(
+        (specifier, index) => `import type * as Entry${index} from ${JSON.stringify(specifier)};`,
+      )
+      .join('\n')}\n\n${entryPoints
+      .map((_, index) => `void (0 as unknown as typeof Entry${index});`)
+      .join('\n')}\n`,
+  );
+}
+
+async function validateLinkedPackages(root, names, packages) {
+  for (const name of names) {
+    const installedRoot = await realpath(join(root, 'node_modules', name));
+    const expectedRoot = await realpath(requiredPackage(packages, name).directory);
+    if (installedRoot !== expectedRoot) {
+      throw new Error(`Linked ${name} resolved to ${installedRoot}; expected ${expectedRoot}`);
+    }
+  }
+}
+
+async function validateInstalledPackages(root, names, packages) {
+  const realFixtureRoot = await realpath(root);
+  for (const name of names) {
+    const installedManifestPath = join(root, 'node_modules', name, 'package.json');
+    const installedManifest = JSON.parse(await readFile(installedManifestPath, 'utf8'));
+    const expectedManifest = requiredPackage(packages, name).manifest;
+    if (installedManifest.version !== expectedManifest.version) {
+      throw new Error(
+        `Packed ${name} has version ${installedManifest.version}; expected ${expectedManifest.version}`,
+      );
+    }
+    const workspaceRange = findWorkspaceRange(installedManifest);
+    if (workspaceRange)
+      throw new Error(`Packed ${name} contains a workspace range at ${workspaceRange}`);
+    validateDefaultInternalImports(name, installedManifest);
+    const installedRoot = await realpath(join(root, 'node_modules', name));
+    if (!installedRoot.startsWith(realFixtureRoot)) {
+      throw new Error(`Packed ${name} resolved outside the external consumer`);
+    }
+  }
+}
+
+function validateDefaultInternalImports(name, manifest) {
+  const internalImports = manifest.imports?.['#*'];
+  if (internalImports === undefined) return;
+  if (
+    !internalImports ||
+    typeof internalImports !== 'object' ||
+    Array.isArray(internalImports) ||
+    internalImports.default !== './dist/*'
+  ) {
+    throw new Error(`Packed ${name} does not map the default #* condition to ./dist/*`);
+  }
+}
+
+async function validateDefaultPackageResolution(root, specifiers) {
+  const resolution = await run(
+    process.execPath,
+    [
+      '--input-type=module',
+      '--eval',
+      `const specifiers = ${JSON.stringify(specifiers)};
+const resolved = Object.fromEntries(specifiers.map((specifier) => [specifier, import.meta.resolve(specifier)]));
+process.stdout.write(JSON.stringify(resolved));`,
+    ],
+    root,
+    {capture: true},
+  );
+  const resolved = JSON.parse(resolution.stdout);
+  for (const specifier of specifiers) {
+    const resolvedPath = fileURLToPath(resolved[specifier]);
+    if (!resolvedPath.split(sep).includes('dist')) {
+      throw new Error(`Packed ${specifier} resolved to source instead of dist: ${resolvedPath}`);
+    }
+  }
+}
+
+async function validateNoRegistryShipfoxPackages(root) {
+  const virtualStore = await readdir(join(root, 'node_modules/.pnpm'), {withFileTypes: true});
+  const registryPackages = virtualStore
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name)
+    .filter((name) => REGISTRY_SHIPFOX_PACKAGE_PATTERN.test(name));
+  if (registryPackages.length) {
+    throw new Error(
+      `External consumer used registry Shipfox packages: ${registryPackages.join(', ')}`,
+    );
+  }
+}
+
+function requiredPackage(packages, name) {
+  const workspacePackage = packages.get(name);
+  if (!workspacePackage) throw new Error(`Missing workspace package: ${name}`);
+  return workspacePackage;
+}
+
+function listConcreteEntryPoints(name, workspacePackage) {
+  return listPublicPackageEntryPoints(name, workspacePackage.manifest.exports).flatMap(
+    (entryPoint) => {
+      if (!entryPoint.specifier.includes('*')) return entryPoint;
+      return concretePatternEntryPoints(entryPoint, workspacePackage.directory);
+    },
+  );
+}
+
+function concretePatternEntryPoints(entryPoint, packageDirectory) {
+  const runtimeTarget = defaultRuntimeTarget(entryPoint.target);
+  if (!runtimeTarget?.includes('*')) {
+    throw new Error(
+      `Wildcard export ${entryPoint.specifier} must define a default JavaScript target.`,
+    );
+  }
+
+  const targetPattern = runtimeTarget.slice(2);
+  const globPattern = targetPattern.replace('*', '**/*');
+  const capturePattern = new RegExp(
+    `^${targetPattern
+      .split('*')
+      .map((segment) => segment.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&'))
+      .join('(.+)')}$`,
+  );
+  const concreteEntryPoints = globSync(join(packageDirectory, globPattern)).map((path) => {
+    const relativePath = relative(packageDirectory, path).split(sep).join('/');
+    const match = capturePattern.exec(relativePath);
+    if (!match) {
+      throw new Error(
+        `Wildcard export ${entryPoint.specifier} resolved ${relativePath} outside ${runtimeTarget}.`,
+      );
+    }
+    return {...entryPoint, specifier: entryPoint.specifier.replace('*', match[1])};
+  });
+
+  if (!concreteEntryPoints.length) {
+    throw new Error(
+      `Wildcard export ${entryPoint.specifier} did not resolve any files matching ${runtimeTarget}.`,
+    );
+  }
+
+  return concreteEntryPoints;
+}
+
+function defaultRuntimeTarget(target) {
+  if (typeof target === 'string') return target.endsWith('.js') ? target : undefined;
+  if (!target || typeof target !== 'object' || Array.isArray(target)) return undefined;
+  const defaultTarget = target.default;
+  return defaultTarget === undefined ? undefined : defaultRuntimeTarget(defaultTarget);
+}
+
+function findWorkspaceRange(value, path = 'package.json') {
+  if (typeof value === 'string') return value.startsWith('workspace:') ? path : undefined;
+  if (!value || typeof value !== 'object') return undefined;
+  for (const [key, child] of Object.entries(value)) {
+    const found = findWorkspaceRange(child, `${path}.${key}`);
+    if (found) return found;
+  }
+  return undefined;
+}
+
+function safePackageName(name) {
+  return name.replace('@shipfox/', '').replaceAll('/', '-');
+}
+
+async function mapWithConcurrency(values, concurrency, mapper) {
+  const results = new Array(values.length);
+  let nextIndex = 0;
+
+  async function worker() {
+    while (nextIndex < values.length) {
+      const index = nextIndex;
+      nextIndex += 1;
+      results[index] = await mapper(values[index], index);
+    }
+  }
+
+  await Promise.all(Array.from({length: concurrency}, () => worker()));
+  return results;
+}
+
+function run(command, args, cwd, options = {}) {
+  const {allowFailure = false, capture = false, env = {}} = options;
+  return new Promise((resolvePromise, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      env: {...process.env, ...env},
+      stdio: capture ? ['ignore', 'pipe', 'pipe'] : 'inherit',
+    });
+    let stdout = '';
+    let stderr = '';
+    child.stdout?.on('data', (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr?.on('data', (chunk) => {
+      stderr += chunk;
+    });
+    child.on('error', reject);
+    child.on('exit', (code) => {
+      const result = {code: code ?? 1, stdout, stderr};
+      if (code === 0 || allowFailure) resolvePromise(result);
+      else {
+        reject(
+          new Error(
+            `${basename(command)} ${args.join(' ')} exited with code ${code}${capture ? `\n${stdout}\n${stderr}` : ''}`,
+          ),
+        );
+      }
+    });
+  });
+}