@openrouter/sdk 1.3.20 → 1.3.22

package/esm/models/outputcustomtoolcallitem.js

@@ -11,18 +11,9 @@ export const OutputCustomToolCallItemStatus = {
     Completed: "completed",
     Incomplete: "incomplete",
 };
-export const OutputCustomToolCallItemType = {
-    CustomToolCall: "custom_tool_call",
-};
 /** @internal */
 export const OutputCustomToolCallItemStatus$inboundSchema = openEnums.inboundSchema(OutputCustomToolCallItemStatus);
 /** @internal */
-export const OutputCustomToolCallItemStatus$outboundSchema = openEnums.outboundSchema(OutputCustomToolCallItemStatus);
-/** @internal */
-export const OutputCustomToolCallItemType$inboundSchema = z.enum(OutputCustomToolCallItemType);
-/** @internal */
-export const OutputCustomToolCallItemType$outboundSchema = OutputCustomToolCallItemType$inboundSchema;
-/** @internal */
 export const OutputCustomToolCallItem$inboundSchema = z.object({
     async: z.boolean().optional(),
     call_id: z.string(),
@@ -31,30 +22,12 @@ export const OutputCustomToolCallItem$inboundSchema = z.object({
     name: z.string(),
     namespace: z.string().optional(),
     status: OutputCustomToolCallItemStatus$inboundSchema.optional(),
-    type: OutputCustomToolCallItemType$inboundSchema,
+    type: z.literal("custom_tool_call"),
 }).transform((v) => {
     return remap$(v, {
         "call_id": "callId",
     });
 });
-/** @internal */
-export const OutputCustomToolCallItem$outboundSchema = z.object({
-    async: z.boolean().optional(),
-    callId: z.string(),
-    id: z.string().optional(),
-    input: z.string(),
-    name: z.string(),
-    namespace: z.string().optional(),
-    status: OutputCustomToolCallItemStatus$outboundSchema.optional(),
-    type: OutputCustomToolCallItemType$outboundSchema,
-}).transform((v) => {
-    return remap$(v, {
-        callId: "call_id",
-    });
-});
-export function outputCustomToolCallItemToJSON(outputCustomToolCallItem) {
-    return JSON.stringify(OutputCustomToolCallItem$outboundSchema.parse(outputCustomToolCallItem));
-}
 export function outputCustomToolCallItemFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputCustomToolCallItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputCustomToolCallItem' from JSON`);
 }

package/esm/models/outputfunctioncallitem.d.ts

@@ -15,10 +15,6 @@ export declare const OutputFunctionCallItemStatusCompleted: {
 };
 export type OutputFunctionCallItemStatusCompleted = ClosedEnum<typeof OutputFunctionCallItemStatusCompleted>;
 export type OutputFunctionCallItemStatusUnion = OutputFunctionCallItemStatusCompleted | OutputFunctionCallItemStatusIncomplete | OutputFunctionCallItemStatusInProgress;
-export declare const OutputFunctionCallItemType: {
-    readonly FunctionCall: "function_call";
-};
-export type OutputFunctionCallItemType = ClosedEnum<typeof OutputFunctionCallItemType>;
 export type OutputFunctionCallItemSubagentItem = {
     type: string;
     additionalProperties?: {
@@ -39,7 +35,7 @@ export type OutputFunctionCallItem = {
      */
     namespace?: string | undefined;
     status?: OutputFunctionCallItemStatusCompleted | OutputFunctionCallItemStatusIncomplete | OutputFunctionCallItemStatusInProgress | undefined;
-    type: OutputFunctionCallItemType;
+    type: "function_call";
     /**
      * EXPERIMENTAL — subject to change without notice. String id that matches the `call_id` of the `openrouter:subagent` server tool call that spawned the subagent. Present on every `function_call` item the subagent projects; absent on ordinary function calls.
      */
@@ -52,55 +48,16 @@ export type OutputFunctionCallItem = {
 /** @internal */
 export declare const OutputFunctionCallItemStatusInProgress$inboundSchema: z.ZodEnum<typeof OutputFunctionCallItemStatusInProgress>;
 /** @internal */
-export declare const OutputFunctionCallItemStatusInProgress$outboundSchema: z.ZodEnum<typeof OutputFunctionCallItemStatusInProgress>;
-/** @internal */
 export declare const OutputFunctionCallItemStatusIncomplete$inboundSchema: z.ZodEnum<typeof OutputFunctionCallItemStatusIncomplete>;
 /** @internal */
-export declare const OutputFunctionCallItemStatusIncomplete$outboundSchema: z.ZodEnum<typeof OutputFunctionCallItemStatusIncomplete>;
-/** @internal */
 export declare const OutputFunctionCallItemStatusCompleted$inboundSchema: z.ZodEnum<typeof OutputFunctionCallItemStatusCompleted>;
 /** @internal */
-export declare const OutputFunctionCallItemStatusCompleted$outboundSchema: z.ZodEnum<typeof OutputFunctionCallItemStatusCompleted>;
-/** @internal */
 export declare const OutputFunctionCallItemStatusUnion$inboundSchema: z.ZodType<OutputFunctionCallItemStatusUnion, unknown>;
-/** @internal */
-export type OutputFunctionCallItemStatusUnion$Outbound = string | string | string;
-/** @internal */
-export declare const OutputFunctionCallItemStatusUnion$outboundSchema: z.ZodType<OutputFunctionCallItemStatusUnion$Outbound, OutputFunctionCallItemStatusUnion>;
-export declare function outputFunctionCallItemStatusUnionToJSON(outputFunctionCallItemStatusUnion: OutputFunctionCallItemStatusUnion): string;
 export declare function outputFunctionCallItemStatusUnionFromJSON(jsonString: string): SafeParseResult<OutputFunctionCallItemStatusUnion, SDKValidationError>;
 /** @internal */
-export declare const OutputFunctionCallItemType$inboundSchema: z.ZodEnum<typeof OutputFunctionCallItemType>;
-/** @internal */
-export declare const OutputFunctionCallItemType$outboundSchema: z.ZodEnum<typeof OutputFunctionCallItemType>;
-/** @internal */
 export declare const OutputFunctionCallItemSubagentItem$inboundSchema: z.ZodType<OutputFunctionCallItemSubagentItem, unknown>;
-/** @internal */
-export type OutputFunctionCallItemSubagentItem$Outbound = {
-    type: string;
-    [additionalProperties: string]: unknown;
-};
-/** @internal */
-export declare const OutputFunctionCallItemSubagentItem$outboundSchema: z.ZodType<OutputFunctionCallItemSubagentItem$Outbound, OutputFunctionCallItemSubagentItem>;
-export declare function outputFunctionCallItemSubagentItemToJSON(outputFunctionCallItemSubagentItem: OutputFunctionCallItemSubagentItem): string;
 export declare function outputFunctionCallItemSubagentItemFromJSON(jsonString: string): SafeParseResult<OutputFunctionCallItemSubagentItem, SDKValidationError>;
 /** @internal */
 export declare const OutputFunctionCallItem$inboundSchema: z.ZodType<OutputFunctionCallItem, unknown>;
-/** @internal */
-export type OutputFunctionCallItem$Outbound = {
-    arguments: string;
-    async?: boolean | undefined;
-    call_id: string;
-    id?: string | undefined;
-    name: string;
-    namespace?: string | undefined;
-    status?: string | string | string | undefined;
-    type: string;
-    subagent_id?: string | undefined;
-    subagent_items?: Array<OutputFunctionCallItemSubagentItem$Outbound> | undefined;
-};
-/** @internal */
-export declare const OutputFunctionCallItem$outboundSchema: z.ZodType<OutputFunctionCallItem$Outbound, OutputFunctionCallItem>;
-export declare function outputFunctionCallItemToJSON(outputFunctionCallItem: OutputFunctionCallItem): string;
 export declare function outputFunctionCallItemFromJSON(jsonString: string): SafeParseResult<OutputFunctionCallItem, SDKValidationError>;
 //# sourceMappingURL=outputfunctioncallitem.d.ts.map

package/esm/models/outputfunctioncallitem.js

@@ -14,62 +14,25 @@ export const OutputFunctionCallItemStatusIncomplete = {
 export const OutputFunctionCallItemStatusCompleted = {
     Completed: "completed",
 };
-export const OutputFunctionCallItemType = {
-    FunctionCall: "function_call",
-};
 /** @internal */
 export const OutputFunctionCallItemStatusInProgress$inboundSchema = z.enum(OutputFunctionCallItemStatusInProgress);
 /** @internal */
-export const OutputFunctionCallItemStatusInProgress$outboundSchema = OutputFunctionCallItemStatusInProgress$inboundSchema;
-/** @internal */
 export const OutputFunctionCallItemStatusIncomplete$inboundSchema = z.enum(OutputFunctionCallItemStatusIncomplete);
 /** @internal */
-export const OutputFunctionCallItemStatusIncomplete$outboundSchema = OutputFunctionCallItemStatusIncomplete$inboundSchema;
-/** @internal */
 export const OutputFunctionCallItemStatusCompleted$inboundSchema = z.enum(OutputFunctionCallItemStatusCompleted);
 /** @internal */
-export const OutputFunctionCallItemStatusCompleted$outboundSchema = OutputFunctionCallItemStatusCompleted$inboundSchema;
-/** @internal */
 export const OutputFunctionCallItemStatusUnion$inboundSchema = z.union([
     OutputFunctionCallItemStatusCompleted$inboundSchema,
     OutputFunctionCallItemStatusIncomplete$inboundSchema,
     OutputFunctionCallItemStatusInProgress$inboundSchema,
 ]);
-/** @internal */
-export const OutputFunctionCallItemStatusUnion$outboundSchema = z.union([
-    OutputFunctionCallItemStatusCompleted$outboundSchema,
-    OutputFunctionCallItemStatusIncomplete$outboundSchema,
-    OutputFunctionCallItemStatusInProgress$outboundSchema,
-]);
-export function outputFunctionCallItemStatusUnionToJSON(outputFunctionCallItemStatusUnion) {
-    return JSON.stringify(OutputFunctionCallItemStatusUnion$outboundSchema.parse(outputFunctionCallItemStatusUnion));
-}
 export function outputFunctionCallItemStatusUnionFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputFunctionCallItemStatusUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputFunctionCallItemStatusUnion' from JSON`);
 }
 /** @internal */
-export const OutputFunctionCallItemType$inboundSchema = z.enum(OutputFunctionCallItemType);
-/** @internal */
-export const OutputFunctionCallItemType$outboundSchema = OutputFunctionCallItemType$inboundSchema;
-/** @internal */
 export const OutputFunctionCallItemSubagentItem$inboundSchema = collectExtraKeys$(z.object({
     type: z.string(),
 }).catchall(z.any()), "additionalProperties", true);
-/** @internal */
-export const OutputFunctionCallItemSubagentItem$outboundSchema = z.object({
-    type: z.string(),
-    additionalProperties: z.record(z.string(), z.any()).optional(),
-}).transform((v) => {
-    return {
-        ...v.additionalProperties,
-        ...remap$(v, {
-            additionalProperties: null,
-        }),
-    };
-});
-export function outputFunctionCallItemSubagentItemToJSON(outputFunctionCallItemSubagentItem) {
-    return JSON.stringify(OutputFunctionCallItemSubagentItem$outboundSchema.parse(outputFunctionCallItemSubagentItem));
-}
 export function outputFunctionCallItemSubagentItemFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputFunctionCallItemSubagentItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputFunctionCallItemSubagentItem' from JSON`);
 }
@@ -86,7 +49,7 @@ export const OutputFunctionCallItem$inboundSchema = z.object({
         OutputFunctionCallItemStatusIncomplete$inboundSchema,
         OutputFunctionCallItemStatusInProgress$inboundSchema,
     ]).optional(),
-    type: OutputFunctionCallItemType$inboundSchema,
+    type: z.literal("function_call"),
     subagent_id: z.string().optional(),
     subagent_items: z.array(z.lazy(() => OutputFunctionCallItemSubagentItem$inboundSchema)).optional(),
 }).transform((v) => {
@@ -96,32 +59,6 @@ export const OutputFunctionCallItem$inboundSchema = z.object({
         "subagent_items": "subagentItems",
     });
 });
-/** @internal */
-export const OutputFunctionCallItem$outboundSchema = z.object({
-    arguments: z.string(),
-    async: z.boolean().optional(),
-    callId: z.string(),
-    id: z.string().optional(),
-    name: z.string(),
-    namespace: z.string().optional(),
-    status: z.union([
-        OutputFunctionCallItemStatusCompleted$outboundSchema,
-        OutputFunctionCallItemStatusIncomplete$outboundSchema,
-        OutputFunctionCallItemStatusInProgress$outboundSchema,
-    ]).optional(),
-    type: OutputFunctionCallItemType$outboundSchema,
-    subagentId: z.string().optional(),
-    subagentItems: z.array(z.lazy(() => OutputFunctionCallItemSubagentItem$outboundSchema)).optional(),
-}).transform((v) => {
-    return remap$(v, {
-        callId: "call_id",
-        subagentId: "subagent_id",
-        subagentItems: "subagent_items",
-    });
-});
-export function outputFunctionCallItemToJSON(outputFunctionCallItem) {
-    return JSON.stringify(OutputFunctionCallItem$outboundSchema.parse(outputFunctionCallItem));
-}
 export function outputFunctionCallItemFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputFunctionCallItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputFunctionCallItem' from JSON`);
 }

package/esm/models/outputitems.d.ts

@@ -40,13 +40,9 @@ export type OutputItems = OutputApplyPatchCallItem | (OutputCodeInterpreterCallI
     type: "code_interpreter_call";
 }) | (OutputComputerCallItem & {
     type: "computer_call";
-}) | (OutputCustomToolCallItem & {
-    type: "custom_tool_call";
-}) | (OutputFileSearchCallItem & {
+}) | OutputCustomToolCallItem | (OutputFileSearchCallItem & {
     type: "file_search_call";
-}) | (OutputFunctionCallItem & {
-    type: "function_call";
-}) | (OutputImageGenerationCallItem & {
+}) | OutputFunctionCallItem | (OutputImageGenerationCallItem & {
     type: "image_generation_call";
 }) | OutputMessageItem | (OutputAdvisorServerToolItem & {
     type: "openrouter:advisor";

package/esm/models/outputitems.js

@@ -41,9 +41,9 @@ export const OutputItems$inboundSchema = discriminatedUnion("type", {
     apply_patch_call: OutputApplyPatchCallItem$inboundSchema,
     code_interpreter_call: OutputCodeInterpreterCallItem$inboundSchema.and(z.object({ type: z.literal("code_interpreter_call") })),
     computer_call: OutputComputerCallItem$inboundSchema.and(z.object({ type: z.literal("computer_call") })),
-    custom_tool_call: OutputCustomToolCallItem$inboundSchema.and(z.object({ type: z.literal("custom_tool_call") })),
+    custom_tool_call: OutputCustomToolCallItem$inboundSchema,
     file_search_call: OutputFileSearchCallItem$inboundSchema.and(z.object({ type: z.literal("file_search_call") })),
-    function_call: OutputFunctionCallItem$inboundSchema.and(z.object({ type: z.literal("function_call") })),
+    function_call: OutputFunctionCallItem$inboundSchema,
     image_generation_call: OutputImageGenerationCallItem$inboundSchema.and(z.object({ type: z.literal("image_generation_call") })),
     message: OutputMessageItem$inboundSchema,
     ["openrouter:advisor"]: OutputAdvisorServerToolItem$inboundSchema.and(z.object({ type: z.literal("openrouter:advisor") })),

package/esm/sdk/interns.d.ts

@@ -80,5 +80,18 @@ export declare class Interns extends ClientSDK {
         };
     }, options?: RequestOptions): Promise<operations.CreateInternChatCompletionResponse>;
     chat(request: operations.CreateInternChatCompletionRequest, options?: RequestOptions): Promise<operations.CreateInternChatCompletionResponse>;
+    /**
+     * Start an intern run without waiting for it
+     *
+     * @remarks
+     * Starts a run on one of your interns and answers `202` with the `session_id` as soon as the intern accepts it. The run keeps going on the intern after the response. Nothing about its progress comes back on this request; the intern reports through its own tools, such as Slack.
+     *
+     * Send the same `session_id` later to continue the conversation, for example to hand the intern a decision on work it started. If that session already has a run going, the prompt is delivered into it and the status is `steered`. A `session_id` is accepted only from the caller it was issued to, on the same intern; any other, including sessions started from Slack or the chat endpoint, is refused with `404`.
+     *
+     * Runs started here self-drive: the intern consents to its own tool approvals, and a question it asks is answered by its own fallback. A run ends when the intern finishes it or after its execution deadline (1 hour by default).
+     *
+     * Available to interns programme members. Callers outside the programme receive `404` for every path under `/api/v1/interns`.
+     */
+    invoke(request: operations.InvokeInternRequest, options?: RequestOptions): Promise<operations.InvokeInternResponse>;
 }
 //# sourceMappingURL=interns.d.ts.map

package/esm/sdk/interns.js

@@ -6,6 +6,7 @@ import { internsChat } from "../funcs/internsChat.js";
 import { internsCreateIntern } from "../funcs/internsCreateIntern.js";
 import { internsDeleteIntern } from "../funcs/internsDeleteIntern.js";
 import { internsGetIntern } from "../funcs/internsGetIntern.js";
+import { internsInvoke } from "../funcs/internsInvoke.js";
 import { internsListInterns } from "../funcs/internsListInterns.js";
 import { internsProvisionIntern } from "../funcs/internsProvisionIntern.js";
 import { internsSuspendIntern } from "../funcs/internsSuspendIntern.js";
@@ -79,5 +80,20 @@ export class Interns extends ClientSDK {
     async chat(request, options) {
         return unwrapAsync(internsChat(this, request, options));
     }
+    /**
+     * Start an intern run without waiting for it
+     *
+     * @remarks
+     * Starts a run on one of your interns and answers `202` with the `session_id` as soon as the intern accepts it. The run keeps going on the intern after the response. Nothing about its progress comes back on this request; the intern reports through its own tools, such as Slack.
+     *
+     * Send the same `session_id` later to continue the conversation, for example to hand the intern a decision on work it started. If that session already has a run going, the prompt is delivered into it and the status is `steered`. A `session_id` is accepted only from the caller it was issued to, on the same intern; any other, including sessions started from Slack or the chat endpoint, is refused with `404`.
+     *
+     * Runs started here self-drive: the intern consents to its own tool approvals, and a question it asks is answered by its own fallback. A run ends when the intern finishes it or after its execution deadline (1 hour by default).
+     *
+     * Available to interns programme members. Callers outside the programme receive `404` for every path under `/api/v1/interns`.
+     */
+    async invoke(request, options) {
+        return unwrapAsync(internsInvoke(this, request, options));
+    }
 }
 //# sourceMappingURL=interns.js.map

package/jsr.json

@@ -2,7 +2,7 @@
 
 {
   "name": "@openrouter/sdk",
-  "version": "1.3.20",
+  "version": "1.3.22",
   "exports": {
     ".": "./src/index.ts",    
     "./models/errors": "./src/models/errors/index.ts",    

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openrouter/sdk",
-  "version": "1.3.20",
+  "version": "1.3.22",
   "author": "OpenRouter",
   "description": "The OpenRouter TypeScript SDK is a type-safe toolkit for building AI applications with access to 400+ language models through a unified API.",
   "keywords": [
@@ -71,19 +71,21 @@
   },
   "scripts": {
     "lint": "eslint --cache --max-warnings=0 src",
-    "build": "tsc",
+    "build": "tsc && node scripts/unbarrel-imports.js",
     "prepublishOnly": "npm run build",
-    "compile": "tsc",
-    "postinstall": "node scripts/check-types.js || true",
-    "test:e2e": "vitest --run --project e2e",
-    "test:watch": "vitest --watch --project unit",
     "typecheck": "tsc --noEmit",
+    "typecheck:transit": "exit 0",
     "prepare": "npm run build",
+    "test:watch": "vitest --watch --project unit",
+    "compile": "tsc && node scripts/unbarrel-imports.js",
+    "postinstall": "node scripts/check-types.js || true",
     "test": "vitest --run --project unit",
-    "test:transit": "exit 0",
-    "typecheck:transit": "exit 0"
+    "test:e2e": "vitest --run --project e2e",
+    "test:transit": "exit 0"
+  },
+  "peerDependencies": {
+    
   },
-  "peerDependencies": {},
   "devDependencies": {
     "@eslint/js": "^9.26.0",
     "@types/node": "^22.13.12",

package/scripts/unbarrel-imports.js

@@ -0,0 +1,296 @@
+#!/usr/bin/env node
+/**
+ * Rewrite namespace barrel imports in the compiled `esm/` output.
+ *
+ * Speakeasy's generated code imports models through namespace barrels
+ * (`import * as operations from "../models/operations/index.js"`). Under a
+ * dynamic `import()` in a single-file bundle, bundlers cannot prune those
+ * `export *` chains, so one function pulls in every model. This rewrites
+ * each such import into named imports from the module that defines each
+ * name, aliased as `<namespace>_<name>` so they never collide with local
+ * declarations. The barrels themselves stay, for public consumers.
+ *
+ * Runs after `tsc` on `esm/`, so Speakeasy's generated `src/` is untouched.
+ * The rewrite is layout-preserving: `ns.Name` becomes `ns_Name` (same length)
+ * and the replacement imports occupy the original import's line, so every
+ * other line and column is where tsc put it and `.js.map` files stay valid.
+ * It refuses, rather than guesses, on anything it cannot rewrite exactly.
+ */
+
+import { readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import path, { basename, dirname, join, relative, resolve, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import ts from 'typescript';
+
+export const ESM = join(resolve(dirname(fileURLToPath(import.meta.url)), '..'), 'esm');
+
+/** Barrel directories, relative to the compiled root. */
+const BARREL_DIRS = ['models', 'models/operations', 'models/errors'];
+
+const barrelsIn = (root) => BARREL_DIRS.map((dir) => resolve(root, dir, 'index.js'));
+
+class UnbarrelError extends Error {}
+
+function fail(file, node, source, message) {
+  const at = node ? `:${source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1}` : '';
+  throw new UnbarrelError(`${file}${at}: ${message}`);
+}
+
+function parse(file) {
+  return ts.createSourceFile(file, readFileSync(file, 'utf8'), ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
+}
+
+/** Every `.js` file under `dir`, recursively. */
+function listModules(dir) {
+  return readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) return listModules(full);
+    return entry.name.endsWith('.js') ? [full] : [];
+  });
+}
+
+/** Resolve a relative specifier from `file` to an absolute module path. */
+function resolveSpecifier(file, specifier) {
+  return specifier.startsWith('.') ? resolve(dirname(file), specifier) : undefined;
+}
+
+/**
+ * A relative ESM specifier from `file` to `module`, always with `/` separators.
+ * `pathApi` is injectable so the Windows behavior can be tested on any OS.
+ */
+export function specifierFor(file, module, pathApi = path) {
+  const joined = pathApi.relative(pathApi.dirname(file), module).split(pathApi.sep).join('/');
+  return joined.startsWith('./') || joined.startsWith('../') ? joined : `./${joined}`;
+}
+
+const isExported = (statement) =>
+  ts.getModifiers(statement)?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+
+/** Names a leaf module defines, mapped to that module. Refuses forms it cannot follow. */
+function moduleExports(module) {
+  const source = parse(module);
+  const names = new Map();
+  for (const statement of source.statements) {
+    if (ts.isExportDeclaration(statement)) {
+      const empty = !statement.moduleSpecifier && statement.exportClause && ts.isNamedExports(statement.exportClause)
+        && statement.exportClause.elements.length === 0;
+      if (!empty) fail(module, statement, source, 'unsupported re-export in a model module');
+      continue;
+    }
+    if (ts.isExportAssignment(statement)) fail(module, statement, source, 'default export in a model module');
+    if (!isExported(statement)) continue;
+    if (ts.isVariableStatement(statement)) {
+      for (const decl of statement.declarationList.declarations) {
+        if (!ts.isIdentifier(decl.name)) fail(module, decl, source, 'destructured export');
+        names.set(decl.name.text, module);
+      }
+    } else if ((ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement)) && statement.name) {
+      names.set(statement.name.text, module);
+    } else {
+      fail(module, statement, source, 'unsupported export form');
+    }
+  }
+  return names;
+}
+
+/**
+ * Map each name exported by a barrel to the module that defines it, following
+ * nested `export * from` barrels. Throws on a duplicate definition.
+ */
+function barrelExports(barrel, seen = new Set()) {
+  if (seen.has(barrel)) return new Map();
+  seen.add(barrel);
+  const source = parse(barrel);
+  const names = new Map();
+  for (const statement of source.statements) {
+    const isStarExport = ts.isExportDeclaration(statement) && !statement.exportClause && statement.moduleSpecifier
+      && ts.isStringLiteral(statement.moduleSpecifier);
+    if (!isStarExport) fail(barrel, statement, source, 'barrel may only contain `export * from "..."`');
+    const target = resolveSpecifier(barrel, statement.moduleSpecifier.text);
+    if (!target) fail(barrel, statement, source, 'barrel re-exports a package, expected a relative module');
+    const nested = target.endsWith(`${sep}index.js`) ? barrelExports(target, seen) : moduleExports(target);
+    for (const [name, module] of nested) {
+      const prior = names.get(name);
+      if (prior && prior !== module) fail(barrel, statement, source, `${name} is exported by both ${prior} and ${module}`);
+      names.set(name, module);
+    }
+  }
+  return names;
+}
+
+/** Namespace imports of one of `barrels` in `source`: `import * as ns from "<barrel>"`. */
+function barrelImports(file, source, barrels) {
+  const found = [];
+  for (const statement of source.statements) {
+    if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
+    const target = resolveSpecifier(file, statement.moduleSpecifier.text);
+    if (!target) continue;
+    const clause = statement.importClause;
+    const bindings = clause?.namedBindings;
+    if (!barrels.includes(target)) {
+      // A namespace import of some other index.js is likely a barrel this
+      // script does not know; refuse rather than leave it silently.
+      if (bindings && ts.isNamespaceImport(bindings) && basename(target) === 'index.js') {
+        fail(file, statement, source, `namespace import of unrecognized barrel ${statement.moduleSpecifier.text} (add it to BARREL_DIRS)`);
+      }
+      continue;
+    }
+    if (!clause || clause.name || !bindings || !ts.isNamespaceImport(bindings)) {
+      fail(file, statement, source, 'barrel imported in an unsupported form (expected `import * as ns`)');
+    }
+    found.push({ statement, namespace: bindings.name.text, barrel: target });
+  }
+  return found;
+}
+
+/** Every identifier name declared or referenced in `source`, to rule out alias collisions. */
+function identifierNames(source) {
+  const names = new Set();
+  const visit = (node) => {
+    if (ts.isIdentifier(node)) names.add(node.text);
+    ts.forEachChild(node, visit);
+  };
+  visit(source);
+  return names;
+}
+
+/** Whether `node` names a property rather than referencing a binding. */
+function isPropertyName(node) {
+  const parent = node.parent;
+  return (ts.isPropertyAccessExpression(parent) && parent.name === node)
+    || ((ts.isPropertyAssignment(parent) || ts.isMethodDeclaration(parent) || ts.isPropertyDeclaration(parent)
+      || ts.isGetAccessorDeclaration(parent) || ts.isSetAccessorDeclaration(parent)) && parent.name === node)
+    || (ts.isBindingElement(parent) && parent.propertyName === node)
+    || ((ts.isImportSpecifier(parent) || ts.isExportSpecifier(parent)) && parent.propertyName === node);
+}
+
+/** Rewrite one file's barrel imports. Returns the new source, or undefined when unchanged. */
+function rewriteFile(file, exportsByBarrel) {
+  const source = parse(file);
+  const imports = barrelImports(file, source, [...exportsByBarrel.keys()]);
+  if (imports.length === 0) return undefined;
+  const byNamespace = new Map(imports.map((entry) => [entry.namespace, entry]));
+  if (byNamespace.size !== imports.length) fail(file, imports[0].statement, source, 'namespace bound twice');
+  const existing = identifierNames(source);
+  const used = new Map([...byNamespace.keys()].map((ns) => [ns, new Set()]));
+  const accesses = [];
+
+  const visit = (node) => {
+    if (ts.isImportDeclaration(node) && imports.some((entry) => entry.statement === node)) return;
+    if (ts.isIdentifier(node) && byNamespace.has(node.text) && !isPropertyName(node)) {
+      const parent = node.parent;
+      if (!ts.isPropertyAccessExpression(parent) || parent.expression !== node || !ts.isIdentifier(parent.name)) {
+        fail(file, node, source, `unsupported use of namespace ${node.text} (only \`${node.text}.Name\` reads can be rewritten)`);
+      }
+      // `ns.x` may sit inside a destructuring target like `{a: ns.x} = y` or
+      // `for ([ns.x] of y)`; climb out of the pattern so the write check sees
+      // the statement-level operator.
+      let pattern = parent;
+      let scope = parent.parent;
+      while (
+        ts.isObjectLiteralExpression(scope) || ts.isArrayLiteralExpression(scope)
+        || ts.isPropertyAssignment(scope) || ts.isShorthandPropertyAssignment(scope)
+        || ts.isSpreadElement(scope) || ts.isSpreadAssignment(scope) || ts.isBindingElement(scope)
+      ) {
+        pattern = scope;
+        scope = scope.parent;
+      }
+      const isWrite = (ts.isBinaryExpression(scope) && scope.left === pattern
+          && scope.operatorToken.kind >= ts.SyntaxKind.FirstAssignment
+          && scope.operatorToken.kind <= ts.SyntaxKind.LastAssignment)
+        || (ts.isDeleteExpression(scope) && scope.expression === pattern)
+        || ((ts.isPrefixUnaryExpression(scope) || ts.isPostfixUnaryExpression(scope)) && scope.operand === pattern
+          && (scope.operator === ts.SyntaxKind.PlusPlusToken || scope.operator === ts.SyntaxKind.MinusMinusToken))
+        || ((ts.isForInStatement(scope) || ts.isForOfStatement(scope)) && scope.initializer === pattern);
+      if (isWrite) fail(file, node, source, `mutation of ${node.text}.${parent.name.text} cannot be rewritten`);
+      used.get(node.text).add(parent.name.text);
+      accesses.push(parent);
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(source);
+
+  const edits = [];
+  for (const { statement, namespace, barrel } of imports) {
+    const exported = exportsByBarrel.get(barrel);
+    const byModule = new Map();
+    for (const name of [...used.get(namespace)].sort()) {
+      const module = exported.get(name);
+      if (!module) fail(file, statement, source, `${namespace}.${name} is not exported by ${relative(dirname(file), barrel)}`);
+      const alias = `${namespace}_${name}`;
+      if (existing.has(alias)) fail(file, statement, source, `alias ${alias} already exists in this module`);
+      if (!byModule.has(module)) byModule.set(module, []);
+      byModule.get(module).push(name);
+    }
+    const replacement = [...byModule]
+      .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+      .map(([module, names]) => {
+        const specifiers = names.map((name) => `${name} as ${namespace}_${name}`).join(', ');
+        return `import { ${specifiers} } from ${JSON.stringify(specifierFor(file, module))};`;
+      })
+      .join(' ');
+    edits.push({ start: statement.getStart(source), end: statement.getEnd(), text: replacement });
+  }
+  for (const access of accesses) {
+    edits.push({ start: access.getStart(source), end: access.getEnd(), text: `${access.expression.text}_${access.name.text}` });
+  }
+
+  const original = source.getFullText();
+  let text = original;
+  for (const edit of edits.sort((a, b) => b.start - a.start)) {
+    text = text.slice(0, edit.start) + edit.text + text.slice(edit.end);
+  }
+  assertLayoutPreserved(file, original, text, imports.map(({ statement }) => source.getLineAndCharacterOfPosition(statement.getStart(source)).line));
+  return text;
+}
+
+/**
+ * Source maps stay valid only if every line other than a rewritten import
+ * line keeps its content length and position. `ns.Name` → `ns_Name` is
+ * length-neutral; import lines only exist at the top, above any mapping.
+ */
+function assertLayoutPreserved(file, before, after, importLines) {
+  const a = before.split('\n');
+  const b = after.split('\n');
+  if (a.length !== b.length) throw new UnbarrelError(`${file}: rewrite changed the line count (${a.length} → ${b.length})`);
+  const rewritten = new Set(importLines);
+  for (let line = 0; line < a.length; line += 1) {
+    if (!rewritten.has(line) && a[line].length !== b[line].length) {
+      throw new UnbarrelError(`${file}:${line + 1}: rewrite changed a column position`);
+    }
+  }
+}
+
+/** Modules under `root` that import a model barrel as a namespace, as `path (namespace)`. */
+export function remainingBarrelImports(root = ESM) {
+  root = resolve(root);
+  const barrels = barrelsIn(root);
+  return listModules(root).flatMap((file) =>
+    barrelImports(file, parse(file), barrels).map(({ namespace }) => `${relative(root, file).split(sep).join('/')} (${namespace})`),
+  );
+}
+
+/** Rewrite every module under `root` in place. Returns the number of files changed. */
+export function unbarrelImports(root = ESM) {
+  root = resolve(root);
+  const exportsByBarrel = new Map(barrelsIn(root).map((barrel) => [barrel, barrelExports(barrel)]));
+  const rewrites = [];
+  for (const file of listModules(root)) {
+    const text = rewriteFile(file, exportsByBarrel);
+    if (text !== undefined) rewrites.push([file, text]);
+  }
+  for (const [file, text] of rewrites) writeFileSync(file, text);
+  const remaining = remainingBarrelImports(root);
+  if (remaining.length > 0) throw new UnbarrelError(`barrel imports left after rewrite:\n${remaining.join('\n')}`);
+  return rewrites.length;
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  try {
+    console.log(`unbarrel-imports: rewrote ${unbarrelImports()} files`);
+  } catch (error) {
+    if (!(error instanceof UnbarrelError)) throw error;
+    console.error(`unbarrel-imports: ${error.message}`);
+    process.exit(1);
+  }
+}