nexus-ai-pro 1.24.0 → 1.25.0

package/API_STABILITY.md

@@ -457,6 +457,21 @@ with nexus-ai-pro and declares the core versions it works with as a peer depende
 - The access rules are a guarantee: loopback binding by default, a token on every request, the token
   in a header for every change, and loopback hosts only unless others are allowed.
 
+## 2.0 preparation stage (1.25.0)
+
+The last 1.x minor deprecates what 2.0 removes. Deprecated APIs keep working, unchanged, for the rest
+of the 1.x line.
+
+- The 2.0 root import keeps the core client, its config builders, the types of its configuration,
+  requests, and responses, and the errors it throws. Every other root export is deprecated in favour of
+  the subpath that already provides it, under the same name or, where noted, another.
+- Every deprecated option warns once per process through Node's `DeprecationWarning` channel, so
+  `--throw-deprecation` finds them in a test run. Deprecated exports and fields are marked in the type
+  declarations, where editors show them.
+- `nexus migrate` and its map follow the root's deprecations; both are generated from the export map,
+  so they cannot disagree.
+- A 1.x checkpoint stays readable throughout 2.x, by both checkpointers and by `migrateCheckpoint()`.
+
 ## Deployment stage (1.24.0)
 
 Deployments (`nexus-ai-pro/server/deployments`), tenant limits (`nexus-ai-pro/server/tenancy`), and the

package/CHANGELOG.md

@@ -4,6 +4,50 @@ Notable changes to this project are recorded here. The format follows [Keep a Ch
 
 ## [Unreleased]
 
+## [1.25.0] - 2026-10-01
+
+The bridge to 2.0. Everything 2.0 removes is deprecated now, every capability has a subpath of its
+own, and the tools to migrate ship with it, so a codebase can move while it is still on 1.x.
+
+### Added
+
+- **A subpath for every capability.** What could only be imported from the root has an entry point
+  of its own, each with no third-party dependency: `nexus-ai-pro/grounding` (grounded prompts,
+  verification, self-consistency, knowledge graphs), `/connectors` (web tools), `/ops` (metrics,
+  health, audit, OpenTelemetry export, rate limiting), `/pipeline`, `/router`, `/testing`
+  (conformance suites), `/next` (the route handler), `/rag/files` (scanned file ingestion), and
+  `/optimizer/cost` (cost estimates and budgets). Grounding alone is 15 KB, where it used to mean the
+  584 KB root and its validators. `hardenPrompt()` joins `/security`, `Tokenizer` joins `/optimizer`, the
+  registry's data joins `/models`, and the capability types join `/capabilities`.
+- **`nexus migrate`**, a codemod that moves imports to the subpaths the 2.0 root keeps them on. It
+  rewrites `import`, `import type`, `export … from`, and destructured `require()` in TypeScript,
+  JavaScript, and Markdown code blocks, keeps local names when a name moved under another, and lists
+  what it cannot rewrite safely. `--check` fails a CI job while anything is left.
+- **`MIGRATING.md`**, shipped in the package: every change 2.0 makes, with before-and-after code.
+- **Modalities with a direction**: `inputModalities` and `outputModalities` on a model's capabilities,
+  `modalitiesOf()` on `nexus-ai-pro/models` to read either shape, and both as routing requirements.
+- **The 2.0 checkpoint schema, readable now**: `migrateCheckpoint()` and `GraphCheckpointV2` on
+  `nexus-ai-pro/graph`.
+
+### Deprecated
+
+- 499 exports of the root import, each in favour of the subpath that already provides it. 2.0 keeps
+  only the core client, its config builders, its types, and the errors it throws on the root. Editors
+  strike a deprecated import through and name the subpath; `nexus migrate` moves them.
+- `ModelCapabilities.modalities` and `routing.requiredCapabilities.modalities`, for the directional
+  fields. The routing requirement warns once per process.
+- `GraphCheckpoint.interrupt`, for `interrupts`.
+
+### Changed
+
+- The guides' examples import from subpaths, as 2.0 requires.
+
+### Fixed
+
+- The agents guide pointed at `nexus-ai-pro/connectors`, which did not exist. It does now.
+- `tenantLimits({ now })` drives the default usage and rate stores too. They kept the system clock, so
+  a budget judged on a replaced clock reset when the real day ended.
+
 ## [1.24.0] - 2026-09-30
 
 Deployment at scale, self-managed. Running assistants as a service without a hosted platform:
@@ -1211,7 +1255,8 @@ shared policy vocabulary is in place for a future release that revisits this.
 - URL fetching rejects unsafe private-network targets and limits response reads.
 - CLI and audit findings no longer disclose detected secret values.
 
-[Unreleased]: https://github.com/mkhitar-abrahamyan/nexus-ai/compare/v1.24.0...HEAD
+[Unreleased]: https://github.com/mkhitar-abrahamyan/nexus-ai/compare/v1.25.0...HEAD
+[1.25.0]: https://github.com/mkhitar-abrahamyan/nexus-ai/compare/v1.24.0...v1.25.0
 [1.24.0]: https://github.com/mkhitar-abrahamyan/nexus-ai/compare/v1.23.0...v1.24.0
 [1.23.0]: https://github.com/mkhitar-abrahamyan/nexus-ai/compare/v1.22.0...v1.23.0
 [1.22.0]: https://github.com/mkhitar-abrahamyan/nexus-ai/compare/v1.21.0...v1.22.0

package/MIGRATING.md

@@ -0,0 +1,169 @@
+# Migrating to 2.0
+
+2.0.0 removes what the 1.x line deprecated. Everything you need to get ready ships in 1.25, so you can
+migrate while you are still on 1.x. Nothing below breaks before 2.0.
+
+Start with the codemod. It rewrites what it can safely, and lists the rest:
+
+```bash
+npx nexus migrate src           # reports what would change
+npx nexus migrate src --write   # rewrites the files
+npx nexus migrate src --check   # exits 1 while anything is left, for CI
+```
+
+Then run your tests with `node --throw-deprecation`. Every deprecated option warns once per process,
+so a clean run means nothing you call is going away.
+
+| Change | The codemod | By hand |
+| --- | --- | --- |
+| [The root import keeps only the core](#the-root-import-keeps-only-the-core) | Rewrites the imports | Namespace and dynamic imports of the root |
+| [`estimatedCost` is removed](#a-responses-estimatedcost-is-removed) | Lists each read | Read `cost.amount` |
+| [`ImageManagerConfig` is removed](#imagemanagerconfig-is-removed) | Renames it | — |
+| [Options that were never read are removed](#options-that-were-never-read-are-removed) | — | Delete them; each warns today |
+| [Modalities say which way they flow](#modalities-say-which-way-they-flow) | — | Set the two new fields |
+| [Checkpoints gain ids and lose `interrupt`](#checkpoints-gain-ids-and-lose-interrupt) | — | Read `interrupts` |
+| [Validators and Node types become optional](#validators-and-node-types-become-optional) | — | Install what you use |
+| [Planned, not yet final](#planned-not-yet-final) | — | Nothing yet |
+
+## The root import keeps only the core
+
+In 2.0, `nexus-ai-pro` exports the core client and nothing else. That is:
+
+- `NexusAI`, `createNexus`, and the config builders;
+- `tool()`, the streaming helpers, and the usage and pricing helpers for custom providers;
+- the types of the client's configuration, requests, and responses;
+- the errors the client throws: `NexusProviderError`, `NexusSecurityError`, `NexusRateLimitError`,
+  `NexusCapabilityError`, `TokenBudgetError`, `CostBudgetError`, and `ResponseFormatError`.
+
+Every other export is on its own subpath already. In 1.25 each one is deprecated on the root, and your
+editor strikes it through with the subpath to use.
+
+```ts
+// Before
+import { NexusAI, MemoryVectorStore, withRagContext, OperationRunner } from 'nexus-ai-pro';
+
+// After
+import { NexusAI } from 'nexus-ai-pro';
+import { OperationRunner } from 'nexus-ai-pro/operations';
+import { withRagContext } from 'nexus-ai-pro/grounding';
+import { MemoryVectorStore } from 'nexus-ai-pro/rag';
+```
+
+The codemod does this for `import`, `import type`, `export … from`, and destructured `require()`. A
+name that moved under another name keeps its local name through an alias:
+
+```ts
+// Before
+import type { AgentModelClient } from 'nexus-ai-pro';
+// After
+import type { AgentLoopModelClient as AgentModelClient } from 'nexus-ai-pro/agent';
+```
+
+It cannot split a namespace import (`import * as nexus from 'nexus-ai-pro'`) or a dynamic `import()`,
+so it lists them. Import each name you use from its subpath instead. Every subpath and what it costs to
+install is in the [packaging guide](https://github.com/mkhitar-abrahamyan/nexus-ai/blob/main/docs/packaging.md).
+
+The smaller root is the point: an application that uses one family no longer loads the client, its
+validators, or the model registry.
+
+## A response's `estimatedCost` is removed
+
+The formatted string on a response's metadata goes. Read the numeric cost and format it yourself:
+
+```ts
+// Before
+console.log(response.meta.estimatedCost); // '$0.0012'
+
+// After
+const cost = response.meta.cost;
+if (cost) console.log(new Intl.NumberFormat('en-US', { style: 'currency', currency: cost.currency }).format(cost.amount));
+```
+
+A plan's `estimatedCost`, from `ai.plan()`, is an object and stays.
+
+## `ImageManagerConfig` is removed
+
+It was an alias of `ImageConfig`. The codemod renames the import and keeps your local name.
+
+## Options that were never read are removed
+
+These were accepted and ignored. Each one already warns once per process when it is set.
+
+| Option | Deprecated in |
+| --- | --- |
+| `GoogleProviderConfig.projectId` | 1.16.0 |
+| `OllamaProviderConfig.timeout` | 1.16.0 |
+| `MetricsConfig.prometheus` | 1.16.0 |
+| `DensificationConfig.preserveMarkdown` | 1.16.0 |
+| `HealthConfig.latencyHalfLife` | 1.16.0 |
+| `InjectionDetectionConfig.sensitivity` | 1.19.0 |
+| `ToolPolicyConfig.requiresApproval` | 1.19.0 |
+
+Delete them. Nothing changes, because nothing read them.
+
+## Modalities say which way they flow
+
+A model's `modalities` list mixed inputs and outputs: `vision` meant an image in, and `image` meant an
+image out. 2.0 replaces it with `inputModalities` and `outputModalities`, which 1.25 already reads.
+
+```ts
+// A model you define, before
+models: { registry: { 'my-model': { modalities: ['text', 'vision'], /* … */ } } }
+
+// After: keep modalities until 2.0, and add the two new fields
+models: {
+  registry: {
+    'my-model': { modalities: ['text', 'vision'], inputModalities: ['text', 'image'], outputModalities: ['text'], /* … */ },
+  },
+}
+```
+
+Read either shape through `modalitiesOf()` from `nexus-ai-pro/models`. In routing requirements, replace
+`modalities` with `inputModalities` or `outputModalities`; the old field warns once.
+
+## Checkpoints gain ids and lose `interrupt`
+
+The 2.0 checkpoint schema gives every checkpoint an id and its pending tasks, and keeps questions only
+in `interrupts`. Both checkpointers keep reading 1.x checkpoints throughout 2.x, so stored threads
+resume.
+
+```ts
+// Before
+const question = checkpoint.interrupt;
+
+// After
+const [question] = checkpoint.interrupts ?? [];
+```
+
+To write code against the 2.0 shape today, read checkpoints through `migrateCheckpoint()` from
+`nexus-ai-pro/graph`, which returns it from either schema.
+
+## Validators and Node types become optional
+
+`zod`, `ajv`, and `ajv-formats` become optional peer dependencies, and so does `@types/node`. The target is
+that a graph-only application installs at most 3.5 MB, instead of about 10 MB today.
+
+If you validate with schemas, or compile TypeScript against Node's types, add what you use:
+
+```bash
+npm install zod ajv ajv-formats
+npm install --save-dev @types/node
+```
+
+The 2.0 release notes list exactly which calls need each one.
+
+## Planned, not yet final
+
+These are designed during the 2.0 cycle. This guide gains their before-and-after code when they land.
+
+- **One lifecycle for every operation.** Completions, streams, embeddings, voice, images, jobs, graphs,
+  and agents share authorization, budgets, hooks, audit, metrics, and tracing. Custom providers receive
+  a `ProviderCallContext` with the abort signal, deadline, request id, trace context, and idempotency key.
+- **Typed pipeline contexts.** `PipelineContext` becomes generic over its request and response, and
+  `PipelineStepName` lists only the built-in steps.
+- **Mixed outputs.** A tool result can carry asset references instead of base64 JSON.
+
+## Runtime
+
+2.0 runs on Node 22 and newer. If it ships after Node 22's end of life in April 2027, the floor moves to
+Node 24.

package/README.md

@@ -224,9 +224,13 @@ Shipped so far:
 - a shared studio with accounts, roles, an audit log, and comments; a context hub; insights with
   evaluated fix proposals; and evaluation caching;
 - self-managed deployment at scale: revisions and canaries with automatic rollback, a worker queue
-  that autoscales on Kubernetes, and per-tenant limits.
+  that autoscales on Kubernetes, and per-tenant limits;
+- the bridge to 2.0: every capability on a subpath of its own, everything 2.0 removes deprecated, and
+  a codemod that moves your imports.
 
-Next: 2.0.0 consolidates. The image family leaves experimental once recorded live
+Next: 2.0.0 consolidates. It slims the root import to the core client; `npx nexus migrate src --write`
+moves your imports today, and [MIGRATING.md](https://github.com/mkhitar-abrahamyan/nexus-ai/blob/main/MIGRATING.md)
+covers the rest. The image family leaves experimental once recorded live
 conformance passes on all three backends.
 
 ## Before Production

package/dist/capabilities/negotiate.d.ts

@@ -45,3 +45,4 @@ export interface NegotiateOptions {
  * declaration means the registry does not know, not that the provider refuses.
  */
 export declare function negotiateCompletionRequest(request: CompletionRequest, capabilities: ModelCapabilities | undefined, options?: NegotiateOptions): NegotiationResult<CompletionRequest>;
+export type { CapabilityConfig, CapabilityPolicy, CapabilityWarning, CapabilityWarningAction, } from '../types/capabilities.js';

package/dist/cli/args.js

@@ -3,6 +3,7 @@ import { pathToFileURL } from 'node:url';
 export const BOOLEAN_FLAGS = new Set([
     'all',
     'allow-dataset-mismatch',
+    'check',
     'densify',
     'fail',
     'fail-on-regression',
@@ -10,6 +11,7 @@ export const BOOLEAN_FLAGS = new Set([
     'json',
     'print',
     'reveal-values',
+    'write',
 ]);
 export function parseArgs(args) {
     const positionals = [];

package/dist/cli/migrate.d.ts

@@ -0,0 +1,52 @@
+import { type ParsedArgs } from './args.js';
+/** One thing `migrateSource()` changed, or found and left for a person. */
+export interface MigrationNote {
+    /** The line, starting at 1. */
+    line: number;
+    /** What was done, or what to do. */
+    message: string;
+}
+/** What `migrateSource()` produced for one file's text. */
+export interface MigrationOutcome {
+    /** The text after migration; the input itself when nothing changed. */
+    text: string;
+    /** Imports rewritten and names renamed. */
+    changes: MigrationNote[];
+    /** What it found and could not rewrite safely, for a person to finish. */
+    notes: MigrationNote[];
+}
+/**
+ * Migrates one file's text to the 2.0 imports: names the root import drops are imported from their
+ * subpaths, names that moved under another name keep their local name through an alias, and deprecated
+ * aliases are replaced. What cannot be rewritten safely — a namespace import of the root, a dynamic
+ * import, a read of `estimatedCost` — is reported instead of guessed at.
+ *
+ * Markdown is migrated inside its TypeScript and JavaScript code blocks only. Running it twice changes
+ * nothing the second time.
+ */
+export declare function migrateSource(text: string, options?: {
+    file?: string;
+}): MigrationOutcome;
+/** Options for `migrateFiles()`. */
+export interface MigrateFilesOptions {
+    /** Writes the migrated files. Without it, nothing is written and the result says what would change. */
+    write?: boolean;
+}
+/** What `migrateFiles()` did with one file. */
+export interface FileMigration extends Omit<MigrationOutcome, 'text'> {
+    /** The file, as given or found. */
+    file: string;
+    /** Whether its text changed. */
+    changed: boolean;
+}
+/**
+ * Migrates every source and Markdown file under the given paths, skipping `node_modules`, build
+ * output, and version control. Files are written only with `write`.
+ */
+export declare function migrateFiles(paths: readonly string[], options?: MigrateFilesOptions): Promise<FileMigration[]>;
+/**
+ * `nexus migrate [paths…] [--write] [--check] [--json]` moves imports of the root to the subpaths the
+ * 2.0 root import keeps them on. Without `--write` it only reports; `--check` exits 1 when a file still
+ * needs migrating, for a CI job that keeps a codebase ready.
+ */
+export declare function runMigrateCommand({ positionals, flags }: ParsedArgs): Promise<void>;

package/dist/cli/migrate.js

@@ -0,0 +1,224 @@
+import { readdir, readFile, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { CliUsageError, flagBool, writeJson } from './args.js';
+import { ROOT_MOVES } from './root-moves.js';
+const RENAMES = { ImageManagerConfig: 'ImageConfig' };
+const PACKAGE = 'nexus-ai-pro';
+const CODE_EXTENSIONS = new Set(['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs']);
+const MARKDOWN_EXTENSIONS = new Set(['.md', '.mdx']);
+const FENCE_LANGUAGES = new Set(['ts', 'tsx', 'typescript', 'js', 'jsx', 'javascript', 'mjs', 'cjs', 'mts', 'cts']);
+const SKIPPED_DIRECTORIES = new Set(['node_modules', '.git', 'dist', 'dist-cjs', 'build', 'coverage', '.next', 'out']);
+export function migrateSource(text, options = {}) {
+    const extension = path.extname(options.file ?? '').toLowerCase();
+    if (MARKDOWN_EXTENSIONS.has(extension))
+        return migrateMarkdown(text);
+    return migrateCode(text, 0);
+}
+export async function migrateFiles(paths, options = {}) {
+    const results = [];
+    for (const file of await collect(paths)) {
+        const original = await readFile(file, 'utf8');
+        const outcome = migrateSource(original, { file });
+        const changed = outcome.text !== original;
+        if (changed && options.write)
+            await writeFile(file, outcome.text);
+        if (changed || outcome.notes.length > 0) {
+            results.push({ file, changed, changes: outcome.changes, notes: outcome.notes });
+        }
+    }
+    return results;
+}
+export async function runMigrateCommand({ positionals, flags }) {
+    const write = flagBool(flags, 'write');
+    const checking = flagBool(flags, 'check');
+    if (write && checking)
+        throw new CliUsageError('--write and --check cannot be combined.');
+    const results = await migrateFiles(positionals.length > 0 ? positionals : ['.'], { write });
+    const pending = results.filter((result) => result.changed);
+    if (flagBool(flags, 'json')) {
+        writeJson({ written: write, files: results });
+    }
+    else {
+        for (const result of results) {
+            const verb = result.changed ? (write ? 'migrated' : 'would migrate') : 'needs a look';
+            console.log(`${result.file}: ${verb}`);
+            for (const change of result.changes)
+                console.log(`  ${change.line}: ${change.message}`);
+            for (const note of result.notes)
+                console.log(`  ${note.line}: TODO ${note.message}`);
+        }
+        const notes = results.reduce((total, result) => total + result.notes.length, 0);
+        const summary = pending.length === 0
+            ? 'Nothing to migrate.'
+            : write
+                ? `Migrated ${pending.length} file${pending.length === 1 ? '' : 's'}.`
+                : `${pending.length} file${pending.length === 1 ? '' : 's'} to migrate. Run again with --write.`;
+        console.log(notes > 0 ? `${summary} ${notes} place${notes === 1 ? '' : 's'} to finish by hand.` : summary);
+    }
+    if (checking && pending.length > 0)
+        process.exitCode = 1;
+}
+function migrateMarkdown(text) {
+    const changes = [];
+    const notes = [];
+    const fence = /^([ \t]*)(```+|~~~+)[ \t]*([\w-]*)[^\n]*\n([\s\S]*?)^\1\2[ \t]*$/gm;
+    let output = '';
+    let last = 0;
+    for (const match of text.matchAll(fence)) {
+        const language = (match[3] ?? '').toLowerCase();
+        if (!FENCE_LANGUAGES.has(language))
+            continue;
+        const body = match[4];
+        const bodyStart = (match.index ?? 0) + match[0].indexOf('\n') + 1;
+        const offset = lineOf(text, bodyStart) - 1;
+        const outcome = migrateCode(body, offset);
+        changes.push(...outcome.changes);
+        notes.push(...outcome.notes);
+        if (outcome.text === body)
+            continue;
+        output += text.slice(last, bodyStart) + outcome.text;
+        last = bodyStart + body.length;
+    }
+    return { text: last === 0 ? text : output + text.slice(last), changes, notes };
+}
+const NAMED = /^([ \t]*)(import|export)(\s+type)?\s*\{([^}]*)\}\s*from\s*(['"])(nexus-ai-pro(?:\/[\w./-]+)?)\5([ \t]*;?)/gm;
+const REQUIRE = /^([ \t]*)(const|let|var)\s*\{([^}]*)\}\s*=\s*require\(\s*(['"])(nexus-ai-pro(?:\/[\w./-]+)?)\4\s*\)([ \t]*;?)/gm;
+function migrateCode(text, lineOffset) {
+    const eol = text.includes('\r\n') ? '\r\n' : '\n';
+    const changes = [];
+    const notes = [];
+    const at = (index) => lineOf(text, index) + lineOffset;
+    let output = text.replace(NAMED, (whole, indent, keyword, typeOnly, body, quote, from, end, index) => {
+        const specifiers = parseSpecifiers(body, false);
+        if (!specifiers)
+            return whole;
+        const rewritten = rewrite(specifiers, from, (message) => changes.push({ line: at(index), message }));
+        if (!rewritten)
+            return whole;
+        const multiline = body.includes('\n');
+        return rewritten
+            .map(([module, list]) => `${indent}${keyword}${typeOnly ? ' type' : ''} ${braces(list, indent, multiline, eol, false)} from ${quote}${module}${quote}${end}`)
+            .join(eol);
+    });
+    output = output.replace(REQUIRE, (whole, indent, declaration, body, quote, from, end, index) => {
+        const specifiers = parseSpecifiers(body, true);
+        if (!specifiers)
+            return whole;
+        const rewritten = rewrite(specifiers, from, (message) => changes.push({ line: at(index), message }));
+        if (!rewritten)
+            return whole;
+        const multiline = body.includes('\n');
+        return rewritten
+            .map(([module, list]) => `${indent}${declaration} ${braces(list, indent, multiline, eol, true)} = require(${quote}${module}${quote})${end}`)
+            .join(eol);
+    });
+    for (const match of text.matchAll(/import\s+\*\s+as\s+\w+\s+from\s*['"]nexus-ai-pro['"]/g)) {
+        notes.push({
+            line: at(match.index ?? 0),
+            message: 'a namespace import of the root: import each name from its subpath',
+        });
+    }
+    for (const match of text.matchAll(/export\s+\*\s+from\s*['"]nexus-ai-pro['"]/g)) {
+        notes.push({ line: at(match.index ?? 0), message: 're-exports the whole root: re-export the subpaths you need' });
+    }
+    for (const match of text.matchAll(/\bimport\(\s*['"]nexus-ai-pro['"]\s*\)/g)) {
+        notes.push({
+            line: at(match.index ?? 0),
+            message: 'a dynamic import of the root: import the subpath that has what you use',
+        });
+    }
+    for (const match of text.matchAll(/(?:const|let|var)\s+\w+\s*=\s*require\(\s*['"]nexus-ai-pro['"]\s*\)/g)) {
+        notes.push({
+            line: at(match.index ?? 0),
+            message: 'requires the whole root: require the subpaths that have what you use',
+        });
+    }
+    for (const match of text.matchAll(/\.estimatedCost\b(?!\s*[.?[])/g)) {
+        notes.push({
+            line: at(match.index ?? 0),
+            message: "a response's `estimatedCost` string is removed in 2.0: read `cost.amount`, a number, and format it",
+        });
+    }
+    return { text: output, changes, notes };
+}
+function parseSpecifiers(body, destructuring) {
+    const cleaned = body.replace(/\/\*[\s\S]*?\*\//g, '').replace(/\/\/[^\n]*/g, '');
+    const specifiers = [];
+    for (const part of cleaned.split(',')) {
+        const item = part.trim();
+        if (!item)
+            continue;
+        const match = destructuring
+            ? /^([A-Za-z_$][\w$]*)(?:\s*:\s*([A-Za-z_$][\w$]*))?$/.exec(item)
+            : /^(type\s+)?([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?$/.exec(item);
+        if (!match)
+            return undefined;
+        specifiers.push(destructuring
+            ? { type: false, name: match[1], ...(match[2] ? { alias: match[2] } : {}) }
+            : { type: Boolean(match[1]), name: match[2], ...(match[3] ? { alias: match[3] } : {}) });
+    }
+    return specifiers;
+}
+function rewrite(specifiers, from, record) {
+    const groups = new Map();
+    let touched = false;
+    for (const specifier of specifiers) {
+        let module = from;
+        let name = specifier.name;
+        const move = from === PACKAGE ? ROOT_MOVES[specifier.name] : undefined;
+        if (move) {
+            [module] = move;
+            name = move[1] ?? specifier.name;
+            record(`${specifier.name}: from '${module}'${name === specifier.name ? '' : ` as ${name}`}`);
+            touched = true;
+        }
+        const replacement = RENAMES[name];
+        if (replacement) {
+            record(`${name}: renamed ${replacement}`);
+            name = replacement;
+            touched = true;
+        }
+        const local = specifier.alias ?? specifier.name;
+        const entry = { type: specifier.type, name, ...(local === name ? {} : { alias: local }) };
+        groups.set(module, [...(groups.get(module) ?? []), entry]);
+    }
+    if (!touched)
+        return undefined;
+    return [...groups].sort(([a], [b]) => (a === from ? -1 : b === from ? 1 : a.localeCompare(b)));
+}
+function braces(list, indent, multiline, eol, destructuring) {
+    const items = list.map((item) => destructuring
+        ? item.alias
+            ? `${item.name}: ${item.alias}`
+            : item.name
+        : `${item.type ? 'type ' : ''}${item.name}${item.alias ? ` as ${item.alias}` : ''}`);
+    if (!multiline)
+        return `{ ${items.join(', ')} }`;
+    return `{${eol}${items.map((item) => `${indent}  ${item},`).join(eol)}${eol}${indent}}`;
+}
+function lineOf(text, index) {
+    let line = 1;
+    for (let position = text.indexOf('\n'); position !== -1 && position < index; position = text.indexOf('\n', position + 1)) {
+        line += 1;
+    }
+    return line;
+}
+async function collect(paths) {
+    const files = [];
+    const visit = async (target) => {
+        const info = await stat(target);
+        if (info.isDirectory()) {
+            if (SKIPPED_DIRECTORIES.has(path.basename(target)))
+                return;
+            for (const entry of (await readdir(target)).sort())
+                await visit(path.join(target, entry));
+            return;
+        }
+        const extension = path.extname(target).toLowerCase();
+        if (CODE_EXTENSIONS.has(extension) || MARKDOWN_EXTENSIONS.has(extension))
+            files.push(target);
+    };
+    for (const target of paths)
+        await visit(target);
+    return files;
+}

package/dist/cli/root-moves.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Where each export the 2.0 root import drops lives instead: the subpath, and the name it has there
+ * when that differs. `nexus migrate` rewrites imports from it.
+ */
+export declare const ROOT_MOVES: Readonly<Record<string, readonly [subpath: string, name?: string]>>;