kitcn 0.27.3 → 0.27.5

package/CHANGELOG.md

@@ -1,5 +1,53 @@
 # kitcn
 
+## 0.27.5
+
+### Patch Changes
+
+- [#414](https://github.com/udecode/kitcn/pull/414) [`7b01244`](https://github.com/udecode/kitcn/commit/7b0124498000e6e6ef190b4b529d10026f0a1f16) Thanks [@MikeyZhang75](https://github.com/MikeyZhang75)! - ## Patches
+
+  - Stop `insert().returning({ ... })` reading each row back after writing it. A
+    projected `returning()` is now answered from the values that were just
+    inserted, so an 8-row insert spends 0 reads on post-images instead of 8.
+    Argument-less `returning()` still reads, because `createdAt` is only known
+    once the row is stored.
+  - Stop `insert().onConflictDoUpdate({ ... }).returning()` reading the row back
+    after patching it.
+  - Stop `returning({ _count })` re-fetching each affected row before counting its
+    relations, on `insert()`, `update()` and `delete()`. That is one fewer read
+    per row, and the counts, their `where` filters and `delete()`'s
+    before-cascade ordering are unchanged.
+  - Keep reading the row back on tables with triggers, `aggregateIndex` or
+    `rankIndex`, where a hook can rewrite what gets stored.
+
+## 0.27.4
+
+### Patch Changes
+
+- [#400](https://github.com/udecode/kitcn/pull/400) [`9963d33`](https://github.com/udecode/kitcn/commit/9963d33048ec532f0a2d9a06bb618486856178b1) Thanks [@MikeyZhang75](https://github.com/MikeyZhang75)! - ## Patches
+
+  - Speed up `kitcn analyze` by measuring every selected entry in one bundler pass
+    instead of one pass per entry: 4.3 s → 0.8 s of bundling on the 24-entry example
+    app, with byte-identical `OutMB`. Each entry is still sized as its own
+    independently tree-shaken isolate, so the ranking is unchanged.
+  - Report the hotspot `DepMB` and `Files` columns for the files that carry weight in
+    each entry's isolate. They previously counted every file the bundler parsed,
+    including files tree-shaking dropped entirely, which disagreed with the `--details`
+    package and input tables directly beneath them. Expect both columns to read lower
+    than before for the same code; `OutMB` and `LocMB` are unaffected.
+  - Fix `kitcn analyze` crashing with a bundler stack trace when a Convex entry fails
+    to build. It now lists the entry under `Failed entries:`, keeps reporting every
+    entry that did build, and still exits `1`. This needs esbuild `0.27.7`, which is
+    now the minimum.
+  - Warn which entries had their `./schema` imports externalized after a build error,
+    instead of leaving the default mode silent about approximate dependency sizes. The
+    approximation is applied per entry, so one unbuildable schema import no longer
+    shrinks the numbers for unrelated functions.
+  - Open the interactive analyzer's package and input panes without a second bundle, so
+    moving the selection no longer pauses to rebuild.
+  - Document the hotspot ranking columns, in `--help` and in the CLI reference, along
+    with the `--top-inputs` / `--top-packages` flags.
+
 ## 0.27.3
 
 ### Patch Changes

package/dist/aggregate/index.d.ts

@@ -1,5 +1,5 @@
-import { Bn as ConvexTextBuilderInitial, Xt as ConvexTableWithColumns } from "../capabilities-CLCYgRdY.js";
-import { C as ConvexNumberBuilderInitial, E as ConvexIdBuilderInitial, N as ConvexCustomBuilderInitial } from "../where-clause-compiler-DAPEBp1y.js";
+import { Bn as ConvexTextBuilderInitial, Xt as ConvexTableWithColumns } from "../capabilities-DkfnnNp7.js";
+import { C as ConvexNumberBuilderInitial, E as ConvexIdBuilderInitial, N as ConvexCustomBuilderInitial } from "../where-clause-compiler-DuC8Nr7e.js";
 import * as convex_values0 from "convex/values";
 import { GenericId, Infer, Value } from "convex/values";
 import { DocumentByName, GenericDataModel, GenericDatabaseReader, GenericDatabaseWriter, TableNamesInDataModel } from "convex/server";

package/dist/auth/generated/index.d.ts

@@ -1,2 +1,2 @@
-import { S as defineAuth, _ as GenericAuthBeforeResult, b as GenericAuthTriggerHandlers, g as BetterAuthOptionsWithoutDatabase, i as getGeneratedAuthDisabledReason, n as GeneratedAuthDisabledReasonKind, r as createDisabledAuthRuntime, t as AuthRuntime, v as GenericAuthDefinition, x as GenericAuthTriggers, y as GenericAuthTriggerChange } from "../../generated-contract-disabled-D4mw0d-V.js";
+import { S as defineAuth, _ as GenericAuthBeforeResult, b as GenericAuthTriggerHandlers, g as BetterAuthOptionsWithoutDatabase, i as getGeneratedAuthDisabledReason, n as GeneratedAuthDisabledReasonKind, r as createDisabledAuthRuntime, t as AuthRuntime, v as GenericAuthDefinition, x as GenericAuthTriggers, y as GenericAuthTriggerChange } from "../../generated-contract-disabled-BEc4d98x.js";
 export { type AuthRuntime, BetterAuthOptionsWithoutDatabase, type GeneratedAuthDisabledReasonKind, GenericAuthBeforeResult, GenericAuthDefinition, GenericAuthTriggerChange, GenericAuthTriggerHandlers, GenericAuthTriggers, createDisabledAuthRuntime, defineAuth, getGeneratedAuthDisabledReason };

package/dist/auth/index.d.ts

@@ -1,7 +1,7 @@
 import { a as QueryCtxWithPreferredOrmQueryTable, n as LookupByIdResultByCtx, t as DocByCtx } from "../query-context-DJONf8X5.js";
 import { t as GetAuth } from "../types-Bf3XQex5.js";
 import { t as GenericCtx } from "../context-utils-DwZ3Cam1.js";
-import { S as defineAuth, _ as GenericAuthBeforeResult, a as AuthFunctions, b as GenericAuthTriggerHandlers, c as createApi, d as deleteOneHandler, f as findManyHandler, g as BetterAuthOptionsWithoutDatabase, h as updateOneHandler, i as getGeneratedAuthDisabledReason, l as createHandler, m as updateManyHandler, n as GeneratedAuthDisabledReasonKind, o as Triggers, p as findOneHandler, r as createDisabledAuthRuntime, s as createClient, t as AuthRuntime, u as deleteManyHandler, v as GenericAuthDefinition, x as GenericAuthTriggers, y as GenericAuthTriggerChange } from "../generated-contract-disabled-D4mw0d-V.js";
+import { S as defineAuth, _ as GenericAuthBeforeResult, a as AuthFunctions, b as GenericAuthTriggerHandlers, c as createApi, d as deleteOneHandler, f as findManyHandler, g as BetterAuthOptionsWithoutDatabase, h as updateOneHandler, i as getGeneratedAuthDisabledReason, l as createHandler, m as updateManyHandler, n as GeneratedAuthDisabledReasonKind, o as Triggers, p as findOneHandler, r as createDisabledAuthRuntime, s as createClient, t as AuthRuntime, u as deleteManyHandler, v as GenericAuthDefinition, x as GenericAuthTriggers, y as GenericAuthTriggerChange } from "../generated-contract-disabled-BEc4d98x.js";
 import * as convex_values0 from "convex/values";
 import { Infer } from "convex/values";
 import { AuthConfig, DocumentByName, GenericDataModel, GenericMutationCtx, GenericQueryCtx, GenericSchema, PaginationOptions, PaginationResult, SchemaDefinition, TableNamesInDataModel } from "convex/server";
@@ -111,32 +111,32 @@ type AdapterPaginationOptions = PaginationOptions & {
 };
 declare const adapterWhereValidator: convex_values0.VObject<{
   mode?: "sensitive" | "insensitive" | undefined;
-  operator?: "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "in" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
   connector?: "AND" | "OR" | undefined;
+  operator?: "lt" | "lte" | "gt" | "gte" | "eq" | "in" | "not_in" | "ne" | "contains" | "starts_with" | "ends_with" | undefined;
   value: string | number | boolean | string[] | number[] | null;
   field: string;
 }, {
   connector: convex_values0.VUnion<"AND" | "OR" | undefined, [convex_values0.VLiteral<"AND", "required">, convex_values0.VLiteral<"OR", "required">], "optional", never>;
   field: convex_values0.VString<string, "required">;
   mode: convex_values0.VUnion<"sensitive" | "insensitive" | undefined, [convex_values0.VLiteral<"sensitive", "required">, convex_values0.VLiteral<"insensitive", "required">], "optional", never>;
-  operator: convex_values0.VUnion<"eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "in" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined, [convex_values0.VLiteral<"lt", "required">, convex_values0.VLiteral<"lte", "required">, convex_values0.VLiteral<"gt", "required">, convex_values0.VLiteral<"gte", "required">, convex_values0.VLiteral<"eq", "required">, convex_values0.VLiteral<"in", "required">, convex_values0.VLiteral<"not_in", "required">, convex_values0.VLiteral<"ne", "required">, convex_values0.VLiteral<"contains", "required">, convex_values0.VLiteral<"starts_with", "required">, convex_values0.VLiteral<"ends_with", "required">], "optional", never>;
+  operator: convex_values0.VUnion<"lt" | "lte" | "gt" | "gte" | "eq" | "in" | "not_in" | "ne" | "contains" | "starts_with" | "ends_with" | undefined, [convex_values0.VLiteral<"lt", "required">, convex_values0.VLiteral<"lte", "required">, convex_values0.VLiteral<"gt", "required">, convex_values0.VLiteral<"gte", "required">, convex_values0.VLiteral<"eq", "required">, convex_values0.VLiteral<"in", "required">, convex_values0.VLiteral<"not_in", "required">, convex_values0.VLiteral<"ne", "required">, convex_values0.VLiteral<"contains", "required">, convex_values0.VLiteral<"starts_with", "required">, convex_values0.VLiteral<"ends_with", "required">], "optional", never>;
   value: convex_values0.VUnion<string | number | boolean | string[] | number[] | null, [convex_values0.VString<string, "required">, convex_values0.VFloat64<number, "required">, convex_values0.VBoolean<boolean, "required">, convex_values0.VArray<string[], convex_values0.VString<string, "required">, "required">, convex_values0.VArray<number[], convex_values0.VFloat64<number, "required">, "required">, convex_values0.VNull<null, "required">], "required", never>;
-}, "required", "mode" | "value" | "operator" | "field" | "connector">;
+}, "required", "mode" | "value" | "connector" | "field" | "operator">;
 declare const adapterArgsValidator: convex_values0.VObject<{
-  limit?: number | undefined;
-  offset?: number | undefined;
   select?: string[] | undefined;
-  sortBy?: {
-    direction: "asc" | "desc";
-    field: string;
-  } | undefined;
   where?: {
     mode?: "sensitive" | "insensitive" | undefined;
-    operator?: "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "in" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
     connector?: "AND" | "OR" | undefined;
+    operator?: "lt" | "lte" | "gt" | "gte" | "eq" | "in" | "not_in" | "ne" | "contains" | "starts_with" | "ends_with" | undefined;
     value: string | number | boolean | string[] | number[] | null;
     field: string;
   }[] | undefined;
+  limit?: number | undefined;
+  offset?: number | undefined;
+  sortBy?: {
+    field: string;
+    direction: "asc" | "desc";
+  } | undefined;
   model: string;
 }, {
   limit: convex_values0.VFloat64<number | undefined, "optional">;
@@ -144,32 +144,32 @@ declare const adapterArgsValidator: convex_values0.VObject<{
   offset: convex_values0.VFloat64<number | undefined, "optional">;
   select: convex_values0.VArray<string[] | undefined, convex_values0.VString<string, "required">, "optional">;
   sortBy: convex_values0.VObject<{
-    direction: "asc" | "desc";
     field: string;
+    direction: "asc" | "desc";
   } | undefined, {
     direction: convex_values0.VUnion<"asc" | "desc", [convex_values0.VLiteral<"asc", "required">, convex_values0.VLiteral<"desc", "required">], "required", never>;
     field: convex_values0.VString<string, "required">;
-  }, "optional", "direction" | "field">;
+  }, "optional", "field" | "direction">;
   where: convex_values0.VArray<{
     mode?: "sensitive" | "insensitive" | undefined;
-    operator?: "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "in" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
     connector?: "AND" | "OR" | undefined;
+    operator?: "lt" | "lte" | "gt" | "gte" | "eq" | "in" | "not_in" | "ne" | "contains" | "starts_with" | "ends_with" | undefined;
     value: string | number | boolean | string[] | number[] | null;
     field: string;
   }[] | undefined, convex_values0.VObject<{
     mode?: "sensitive" | "insensitive" | undefined;
-    operator?: "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "in" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
     connector?: "AND" | "OR" | undefined;
+    operator?: "lt" | "lte" | "gt" | "gte" | "eq" | "in" | "not_in" | "ne" | "contains" | "starts_with" | "ends_with" | undefined;
     value: string | number | boolean | string[] | number[] | null;
     field: string;
   }, {
     connector: convex_values0.VUnion<"AND" | "OR" | undefined, [convex_values0.VLiteral<"AND", "required">, convex_values0.VLiteral<"OR", "required">], "optional", never>;
     field: convex_values0.VString<string, "required">;
     mode: convex_values0.VUnion<"sensitive" | "insensitive" | undefined, [convex_values0.VLiteral<"sensitive", "required">, convex_values0.VLiteral<"insensitive", "required">], "optional", never>;
-    operator: convex_values0.VUnion<"eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "in" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined, [convex_values0.VLiteral<"lt", "required">, convex_values0.VLiteral<"lte", "required">, convex_values0.VLiteral<"gt", "required">, convex_values0.VLiteral<"gte", "required">, convex_values0.VLiteral<"eq", "required">, convex_values0.VLiteral<"in", "required">, convex_values0.VLiteral<"not_in", "required">, convex_values0.VLiteral<"ne", "required">, convex_values0.VLiteral<"contains", "required">, convex_values0.VLiteral<"starts_with", "required">, convex_values0.VLiteral<"ends_with", "required">], "optional", never>;
+    operator: convex_values0.VUnion<"lt" | "lte" | "gt" | "gte" | "eq" | "in" | "not_in" | "ne" | "contains" | "starts_with" | "ends_with" | undefined, [convex_values0.VLiteral<"lt", "required">, convex_values0.VLiteral<"lte", "required">, convex_values0.VLiteral<"gt", "required">, convex_values0.VLiteral<"gte", "required">, convex_values0.VLiteral<"eq", "required">, convex_values0.VLiteral<"in", "required">, convex_values0.VLiteral<"not_in", "required">, convex_values0.VLiteral<"ne", "required">, convex_values0.VLiteral<"contains", "required">, convex_values0.VLiteral<"starts_with", "required">, convex_values0.VLiteral<"ends_with", "required">], "optional", never>;
     value: convex_values0.VUnion<string | number | boolean | string[] | number[] | null, [convex_values0.VString<string, "required">, convex_values0.VFloat64<number, "required">, convex_values0.VBoolean<boolean, "required">, convex_values0.VArray<string[], convex_values0.VString<string, "required">, "required">, convex_values0.VArray<number[], convex_values0.VFloat64<number, "required">, "required">, convex_values0.VNull<null, "required">], "required", never>;
-  }, "required", "mode" | "value" | "operator" | "field" | "connector">, "optional">;
-}, "required", "limit" | "model" | "offset" | "select" | "sortBy" | "where" | "sortBy.direction" | "sortBy.field">;
+  }, "required", "mode" | "value" | "connector" | "field" | "operator">, "optional">;
+}, "required", "model" | "select" | "where" | "limit" | "offset" | "sortBy" | "sortBy.field" | "sortBy.direction">;
 declare const hasUniqueFields: (betterAuthSchema: BetterAuthDBSchema, model: string, input: Record<string, any>) => boolean;
 declare const checkUniqueFields: <Schema extends SchemaDefinition<any, any>>(ctx: GenericQueryCtx<GenericDataModel>, schema: Schema, betterAuthSchema: BetterAuthDBSchema, table: string, input: Record<string, any>, doc?: Record<string, any>) => Promise<void>;
 declare const selectFields: <T extends TableNamesInDataModel<GenericDataModel>, D extends DocumentByName<GenericDataModel, T>>(doc: D | null, select?: string[]) => D | null;

package/dist/{capabilities-CLCYgRdY.d.ts → capabilities-DkfnnNp7.d.ts}

@@ -2896,6 +2896,24 @@ declare class GelRelationalQuery<TSchema extends TablesRelationalConfig, TTableC
   rls?: RlsContext | undefined, relationLoading?: {
     concurrency?: number;
   } | undefined, vectorSearchProvider?: VectorSearchProvider | undefined, configuredIndex?: PredicateWhereIndexConfig<TTableConfig> | undefined, countIndexReadiness?: Map<string, Promise<void>>);
+  /**
+   * Relation counts for a document the caller is already holding.
+   *
+   * `returning({ _count })` runs inside the mutation that just wrote the row,
+   * so resolving it through `execute()` spends one `db.get` re-reading a
+   * document that is already in the transaction's write set. The count engine
+   * only ever reads the counted edges' source fields off its parent, and the
+   * caller's document carries all of them, so the root read is pure waste.
+   * Everything else `execute()` would have done to that row — the select-plan
+   * assertion and the RLS select filter — still runs here.
+   *
+   * Reached through the static accessor below rather than exposed on the instance:
+   * `GelRelationalQuery` is the declared return type of the public query
+   * builders, so an instance method would land in every user's autocomplete.
+   */
+  private _countRelationsForHeldRow;
+  /** @internal Accessor for `returning({ _count })`; see `returning-count.ts`. */
+  static countRelationsForHeldRow(query: GelRelationalQuery<any, any, any>, row: Record<string, unknown>, countSelection: Record<string, unknown>): Promise<Record<string, number>>;
   /**
    * The aggregate-index runtime, registered at `createOrm()`.
    *

package/dist/cli.mjs

@@ -454,6 +454,13 @@ Modes:
   (default)            Hotspot analysis (per-function isolate ranking)
   --deploy             Deploy analysis (single isolate bundle, Convex-like)
 
+Hotspot columns (all describe what the entry actually bundles):
+  OutMB                Bundled size of the isolate this entry deploys into
+  DepMB                Source size of the dependency files in that isolate
+  LocMB                Source size of your own Convex files in that isolate
+  Files                Files contributing bytes to that isolate
+  Fns                  Convex handlers exported by the entry
+
 Flags:
   --details            Show extra per-entry/package details
   --input              Include top internal inputs in detail output
@@ -522,13 +529,46 @@ const packageFromInputPath = (inputPath) => {
 	}
 	return "(other)";
 };
-const buildHotspotEntry = (entryPoint, externalizeSchema) => loadEsbuild().build({
+/** Matches the `out: 'e<index>'` names `createHotspotBuildOptions` assigns. */
+const HOTSPOT_ENTRY_OUTPUT_REGEX = /^out\/e(\d+)\.[^/]+$/;
+const isLocalInputPath = (inputPath) => inputPath.startsWith("convex/") || inputPath.startsWith("example/convex/") || inputPath.includes("/example/convex/");
+/**
+* Hotspot ranks each Convex function by the isolate it deploys into, so every
+* entry needs its own fully tree-shaken closure.
+*
+* esbuild parses each input once per build no matter how many entry points it
+* receives, and with splitting OFF every entry output still carries its own
+* independently tree-shaken closure. Passing the whole entry set to one build
+* therefore keeps per-entry byte counts identical to building each entry alone
+* while reading the shared import graph once.
+*
+* Do not turn on `splitting` here. Shared chunks retain code a lone entry would
+* have dropped, which inflates exactly the number this mode ranks by (measured
+* up to +70% on `example`) and turns dynamic imports into extra outputs that
+* carry an `entryPoint`. `--deploy` already owns the split-bundle view.
+*
+* Each entry is given an explicit output name so its result can be found by
+* position instead of by path. esbuild resolves a symlinked source file to its
+* real path before reporting `output.entryPoint`, so matching that field back
+* against the selected entry would silently lose any entry reached through a
+* symlink. Explicit names also make `foo.ts` and `foo.js` in one directory
+* unable to collide on a single output path.
+*
+* `attributeHotspotBuild` must be given the same `entryPoints` array, since the
+* output name is the entry's index in it.
+*/
+const createHotspotBuildOptions = (entryPoints, projectRoot, externalizeSchema) => ({
+	absWorkingDir: projectRoot,
 	bundle: true,
-	entryPoints: [entryPoint],
+	entryPoints: entryPoints.map((entryPoint, index) => ({
+		in: entryPoint,
+		out: `e${index}`
+	})),
 	external: ["convex", "convex/*"],
 	format: "esm",
 	logLevel: "silent",
 	metafile: true,
+	outdir: "out",
 	platform: "browser",
 	target: ["esnext"],
 	conditions: ["convex", "module"],
@@ -539,42 +579,67 @@ const buildHotspotEntry = (entryPoint, externalizeSchema) => loadEsbuild().build
 	write: false,
 	plugins: externalizeSchema ? [schemaExternalFallbackPlugin] : []
 });
-const analyzeHotspotEntry = async (entryPoint, projectRoot, includeDeepData) => {
-	let result;
-	let schemaExternalized = false;
+/**
+* `allowSchemaFallback` is off for the shared pass on purpose. Externalizing
+* `./schema` removes real weight from every entry that imports it, not just the
+* one that failed: forcing it across `example` moved 25 of 26 rows, one by
+* -98%. Letting the shared pass fail and rebuilding per entry instead keeps the
+* approximation on the entries that actually need it.
+*/
+const buildHotspotBundle = async (entryPoints, projectRoot, allowSchemaFallback) => {
 	try {
-		result = await buildHotspotEntry(entryPoint, false);
+		return {
+			result: await loadEsbuild().build(createHotspotBuildOptions(entryPoints, projectRoot, false)),
+			schemaExternalized: false
+		};
 	} catch (error) {
-		if (!shouldRetryWithSchemaExternalized(error)) throw error;
-		result = await buildHotspotEntry(entryPoint, true);
-		schemaExternalized = true;
+		if (!(allowSchemaFallback && shouldRetryWithSchemaExternalized(error))) throw error;
+		return {
+			result: await loadEsbuild().build(createHotspotBuildOptions(entryPoints, projectRoot, true)),
+			schemaExternalized: true
+		};
+	}
+};
+/**
+* Row metrics describe what actually weighs something in the entry's isolate.
+*
+* They count the inputs that emit bytes into that entry's output, which is the
+* same set the `--details` package and input tables below them already report.
+* The build-wide `meta.inputs` cannot answer this: it lists every file esbuild
+* parsed, including ones tree-shaking dropped entirely (534 of 1545 on
+* `example`), and a shared bundle makes it the union across entries rather than
+* one entry's graph. It stays the lookup table for *source* bytes, so `LocMB`
+* and `DepMB` keep measuring source weight rather than post-minify weight.
+*/
+const buildHotspotRow = (params) => {
+	const { entryPoint, projectRoot, inputs, output, includeDeepData, schemaExternalized } = params;
+	const outputInputEntries = Object.entries(output.inputs ?? {});
+	let inputCount = 0;
+	let totalInputBytes = 0;
+	let localInputBytes = 0;
+	for (const [inputPath, value] of outputInputEntries) {
+		if ((value.bytesInOutput ?? 0) <= 0) continue;
+		inputCount += 1;
+		const sourceBytes = inputs[inputPath]?.bytes ?? 0;
+		totalInputBytes += sourceBytes;
+		if (isLocalInputPath(inputPath)) localInputBytes += sourceBytes;
 	}
-	const meta = result.metafile;
-	if (!meta) throw new Error(`No metafile generated for ${entryPoint}`);
-	const output = Object.values(meta.outputs).at(0);
-	if (!output) throw new Error(`No output generated for ${entryPoint}`);
-	const inputEntries = Object.entries(meta.inputs);
-	const totalInputBytes = inputEntries.reduce((sum, [, value]) => sum + (value.bytes ?? 0), 0);
-	const isLocalInput = (inputPath) => inputPath.startsWith("convex/") || inputPath.startsWith("example/convex/") || inputPath.includes("/example/convex/");
-	const localInputBytes = inputEntries.filter(([inputPath]) => isLocalInput(inputPath)).reduce((sum, [, value]) => sum + (value.bytes ?? 0), 0);
 	const row = {
 		entry: path.relative(projectRoot, entryPoint),
-		inputCount: inputEntries.length,
+		inputCount,
 		localInputBytes,
 		dependencyInputBytes: Math.max(0, totalInputBytes - localInputBytes),
-		totalInputBytes,
 		outputBytes: output.bytes,
 		schemaExternalized
 	};
 	if (!includeDeepData) return row;
-	const bytesByInput = new Map(inputEntries.map(([inputPath, value]) => [inputPath, value.bytes ?? 0]));
-	const outputInputs = Object.entries(output.inputs ?? {}).map(([inputPath, value]) => ({
+	const outputInputs = outputInputEntries.map(([inputPath, value]) => ({
 		path: inputPath,
 		bytesInOutput: value.bytesInOutput ?? 0,
-		sourceBytes: bytesByInput.get(inputPath) ?? 0
+		sourceBytes: inputs[inputPath]?.bytes ?? 0
 	})).sort((a, b) => b.bytesInOutput - a.bytesInOutput);
-	const inputSet = new Set(inputEntries.map(([inputPath]) => inputPath));
-	const importsByInput = Object.fromEntries(inputEntries.map(([inputPath, value]) => [inputPath, Array.from(new Set((value.imports ?? []).map((entry) => entry.path).filter((importPath) => typeof importPath === "string" && inputSet.has(importPath))))]));
+	const inputSet = new Set(outputInputEntries.map(([inputPath]) => inputPath));
+	const importsByInput = Object.fromEntries(outputInputEntries.map(([inputPath]) => [inputPath, Array.from(new Set((inputs[inputPath]?.imports ?? []).map((entry) => entry.path).filter((importPath) => typeof importPath === "string" && inputSet.has(importPath))))]));
 	return {
 		...row,
 		deep: {
@@ -583,6 +648,34 @@ const analyzeHotspotEntry = async (entryPoint, projectRoot, includeDeepData) =>
 		}
 	};
 };
+/**
+* Pairs each entry with its output through the position `createHotspotBuildOptions`
+* encoded in the output name, so `entryPoints` must be the array that built `meta`.
+*/
+const attributeHotspotBuild = (params) => {
+	const { entryPoints, projectRoot, meta, includeDeepData, schemaExternalized } = params;
+	const inputs = meta.inputs;
+	const outputByEntryIndex = /* @__PURE__ */ new Map();
+	for (const [outputPath, output] of Object.entries(meta.outputs)) {
+		const index = HOTSPOT_ENTRY_OUTPUT_REGEX.exec(outputPath)?.[1];
+		if (index === void 0) continue;
+		outputByEntryIndex.set(Number(index), output);
+	}
+	const rowsByEntry = /* @__PURE__ */ new Map();
+	for (const [index, entryPoint] of entryPoints.entries()) {
+		const output = outputByEntryIndex.get(index);
+		if (!output) throw new Error(`esbuild produced no output for ${path.relative(projectRoot, entryPoint)}.`);
+		rowsByEntry.set(entryPoint, buildHotspotRow({
+			entryPoint,
+			includeDeepData,
+			inputs,
+			output,
+			projectRoot,
+			schemaExternalized
+		}));
+	}
+	return rowsByEntry;
+};
 const printHotspotTopInputs = (row, options) => {
 	if (!row.deep) return;
 	const internalInputs = row.deep.outputInputs.filter((input) => input.bytesInOutput > 0 && !isNodeModulesInputPath(input.path));
@@ -866,37 +959,106 @@ const collectAnalyzeEntrySelection = async (roots, options) => {
 };
 const MAX_ANALYZE_CONCURRENCY = 8;
 /**
-* esbuild bundles are independent, so the entry sweep runs through a bounded
-* pool instead of one build at a time. The cap stays low enough to avoid
-* oversubscribing esbuild's worker pool on small machines.
+* Only the per-entry recovery sweep still runs multiple builds, so the cap
+* stays low enough to avoid oversubscribing esbuild's worker pool on small
+* machines.
 */
 const resolveAnalyzeConcurrency = (taskCount) => {
 	if (taskCount <= 1) return 1;
 	const cpuCount = os.cpus().length || 1;
 	return Math.max(1, Math.min(MAX_ANALYZE_CONCURRENCY, cpuCount - 1, taskCount));
 };
-const collectHotspotRows = async (roots, options, includeDeepData) => {
-	const { isolateEntries, generatedEntries, entryPoints, handlerExportsByEntry } = await collectAnalyzeEntrySelection(roots, options);
-	const rows = await mapWithConcurrency(entryPoints, resolveAnalyzeConcurrency(entryPoints.length), async (entryPoint) => {
+const toErrorMessage = (error) => error instanceof Error ? error.message : String(error);
+const runHotspotBuild = async (entryPoints, projectRoot, includeDeepData, allowSchemaFallback, build) => {
+	const { result, schemaExternalized } = await build(entryPoints, projectRoot, allowSchemaFallback);
+	const meta = result.metafile;
+	if (!meta) throw new Error("esbuild produced no metafile for the hotspot bundle.");
+	return attributeHotspotBuild({
+		entryPoints,
+		includeDeepData,
+		meta,
+		projectRoot,
+		schemaExternalized
+	});
+};
+/**
+* Recovery path only. A shared build fails as a unit, so one unbuildable entry
+* would take the whole report down. Rebuilding one entry at a time is the only
+* way to say *which* entry is broken, and it reuses the same build options so
+* surviving rows keep the numbers the shared pass would have produced. It is
+* also where the schema fallback belongs, since here it only degrades the
+* entries that actually need it.
+*
+* Reaching this path needs esbuild >= 0.27.7. Earlier builds threw
+* `SyntaxError: Unexpected end of JSON input` out of esbuild's own stdout
+* handler whenever a `metafile: true` build failed, which is outside any promise
+* this module can catch, so the CLI died before any sweep could report a failed
+* row.
+*/
+const sweepHotspotEntriesIndividually = async (entryPoints, projectRoot, includeDeepData, build) => {
+	const results = await mapWithConcurrency(entryPoints, resolveAnalyzeConcurrency(entryPoints.length), async (entryPoint) => {
 		try {
 			return {
-				...await analyzeHotspotEntry(entryPoint, roots.projectRoot, includeDeepData),
-				handlerExports: handlerExportsByEntry.get(entryPoint) ?? []
+				rowsByEntry: await runHotspotBuild([entryPoint], projectRoot, includeDeepData, true, build),
+				failedRows: []
 			};
 		} catch (error) {
 			return {
-				entry: path.relative(roots.projectRoot, entryPoint),
-				error: error instanceof Error ? error.message : String(error)
+				rowsByEntry: /* @__PURE__ */ new Map(),
+				failedRows: [{
+					entry: path.relative(projectRoot, entryPoint),
+					error: toErrorMessage(error)
+				}]
 			};
 		}
 	});
+	const rowsByEntry = /* @__PURE__ */ new Map();
+	const failedRows = [];
+	for (const result of results) {
+		for (const [entryPoint, row] of result.rowsByEntry) rowsByEntry.set(entryPoint, row);
+		failedRows.push(...result.failedRows);
+	}
+	return {
+		rowsByEntry,
+		failedRows
+	};
+};
+const sweepHotspotEntries = async (entryPoints, projectRoot, includeDeepData, build = buildHotspotBundle) => {
+	if (entryPoints.length === 0) return {
+		rowsByEntry: /* @__PURE__ */ new Map(),
+		failedRows: [],
+		fallbackReason: null
+	};
+	try {
+		return {
+			rowsByEntry: await runHotspotBuild(entryPoints, projectRoot, includeDeepData, false, build),
+			failedRows: [],
+			fallbackReason: null
+		};
+	} catch (error) {
+		return {
+			...await sweepHotspotEntriesIndividually(entryPoints, projectRoot, includeDeepData, build),
+			fallbackReason: firstLine(toErrorMessage(error))
+		};
+	}
+};
+const collectHotspotRows = async (roots, options, includeDeepData) => {
+	const { isolateEntries, generatedEntries, entryPoints, handlerExportsByEntry } = await collectAnalyzeEntrySelection(roots, options);
+	const { rowsByEntry, failedRows, fallbackReason } = await sweepHotspotEntries(entryPoints, roots.projectRoot, includeDeepData);
 	return {
 		isolateEntries,
 		generatedEntries,
 		entryPoints,
-		successRows: rows.filter((row) => !("error" in row)).sort((a, b) => b.outputBytes - a.outputBytes),
-		failedRows: rows.filter((row) => "error" in row),
-		handlerExportsByEntry
+		successRows: entryPoints.flatMap((entryPoint) => {
+			const row = rowsByEntry.get(entryPoint);
+			if (!row) return [];
+			return [{
+				...row,
+				handlerExports: handlerExportsByEntry.get(entryPoint) ?? []
+			}];
+		}).sort((a, b) => b.outputBytes - a.outputBytes),
+		failedRows,
+		fallbackReason
 	};
 };
 const buildPackageImportGraphRows = (row, limit = 12) => {
@@ -1021,7 +1183,7 @@ const runHotspotInteractive = async (roots, options) => {
 		...options,
 		includeGenerated: state.includeGenerated,
 		entryPattern: null
-	}, false);
+	}, true);
 	let visibleRows = sortHotspotRows(filterHotspotRows(snapshot.successRows, state.filterQuery), state.sortKey);
 	let watcher = null;
 	let watchTimer = null;
@@ -1029,7 +1191,6 @@ const runHotspotInteractive = async (roots, options) => {
 	let refreshQueued = false;
 	let shouldQuit = false;
 	let listViewportHeight = 10;
-	const deepRowCache = /* @__PURE__ */ new Map();
 	const getSelectedEntry = () => visibleRows.at(state.selectedIndex)?.entry ?? null;
 	const findRowByEntry = (entry) => {
 		if (!entry) return null;
@@ -1064,8 +1225,7 @@ const runHotspotInteractive = async (roots, options) => {
 				...options,
 				includeGenerated: state.includeGenerated,
 				entryPattern: null
-			}, false);
-			deepRowCache.clear();
+			}, true);
 			syncVisibleRows(preferredEntry);
 			state = reduceInteractiveState(state, {
 				type: "setStatus",
@@ -1147,28 +1307,7 @@ const runHotspotInteractive = async (roots, options) => {
 			stdin.setEncoding("utf8");
 		}
 	};
-	const ensureDeepRow = async (entry) => {
-		if (deepRowCache.has(entry)) return deepRowCache.get(entry) ?? null;
-		const entryPoint = path.join(roots.projectRoot, entry);
-		try {
-			const analyzed = await analyzeHotspotEntry(entryPoint, roots.projectRoot, true);
-			const fallbackHandlers = findRowByEntry(entry)?.handlerExports ?? [];
-			const mergedRow = {
-				...analyzed,
-				handlerExports: snapshot.handlerExportsByEntry.get(entryPoint) ?? fallbackHandlers
-			};
-			deepRowCache.set(entry, mergedRow);
-			return mergedRow;
-		} catch (error) {
-			deepRowCache.set(entry, null);
-			state = reduceInteractiveState(state, {
-				type: "setStatus",
-				message: `Detail load failed for ${entry}: ${firstLine(error instanceof Error ? error.message : String(error))}`
-			});
-			return null;
-		}
-	};
-	const renderInteractive = async () => {
+	const renderInteractive = () => {
 		const layout = resolveInteractiveLayout(stdout.columns ?? outputWidth, stdout.rows ?? 30);
 		listViewportHeight = layout.listViewportHeight;
 		state = reduceInteractiveState(state, {
@@ -1176,8 +1315,7 @@ const runHotspotInteractive = async (roots, options) => {
 			topIndex: fitListViewport(visibleRows.length, state.selectedIndex, layout.listViewportHeight, state.topIndex)
 		});
 		const activeEntry = (visibleRows.at(state.selectedIndex) ?? null)?.entry ?? null;
-		let detailRow = findRowByEntry(activeEntry);
-		if (!state.showHelp && activeEntry && state.detailPane !== "handlers") detailRow = await ensureDeepRow(activeEntry);
+		const detailRow = findRowByEntry(activeEntry);
 		const statusLine = state.statusMessage || "Ready";
 		const headerLine = `entries=${visibleRows.length}/${snapshot.successRows.length} sort=${sortLabel(state.sortKey)} filter=${state.filterQuery || "∅"} all=${state.includeGenerated ? "on" : "off"} pane=${state.detailPane} watch=${state.watchEnabled ? "on" : "off"}`;
 		const listLines = (() => {
@@ -1231,7 +1369,7 @@ const runHotspotInteractive = async (roots, options) => {
 	stdin.setEncoding("utf8");
 	try {
 		while (!shouldQuit) {
-			await renderInteractive();
+			renderInteractive();
 			const key = await readKey();
 			if (key === "" || key === "q") {
 				shouldQuit = true;
@@ -1317,7 +1455,7 @@ const runHotspotInteractive = async (roots, options) => {
 const runHotspotAnalysis = async (roots, options) => {
 	if (shouldPromptForHotspotPick(options)) return runHotspotInteractive(roots, options);
 	const includeDeepData = options.details;
-	const { isolateEntries, generatedEntries, entryPoints, successRows, failedRows } = await collectHotspotRows(roots, options, includeDeepData);
+	const { isolateEntries, generatedEntries, entryPoints, successRows, failedRows, fallbackReason } = await collectHotspotRows(roots, options, includeDeepData);
 	if (entryPoints.length === 0) {
 		if (options.includeGenerated) console.log("No matching entries found for the provided regex.");
 		else console.log("No matching Convex handler entries found (files exporting query/mutation/action, including internal variants).");
@@ -1343,6 +1481,9 @@ const runHotspotAnalysis = async (roots, options) => {
 	const actionRows = successRows;
 	console.log(bold("Runtime hotspot analysis (least optimized functions)"));
 	console.log(`isolateEntries=${isolateEntries.length} handlers=${totalHandlers} extraAll=${generatedEntries.length} selected=${entryPoints.length} ok=${successRows.length} failed=${failedRows.length} avg=${formatBytes(outputAverage)}${largest ? ` largest=${largest.entry} (${formatBytes(largest.outputBytes)})` : ""}`);
+	if (fallbackReason) console.log(dim(`note: the shared bundle failed, so entries were rebuilt one at a time: ${fallbackReason}`));
+	const approximateRows = successRows.filter((row) => row.schemaExternalized);
+	if (approximateRows.length > 0) console.log(colorize(`note: schema imports were externalized after a build error for ${approximateRows.length} ${approximateRows.length === 1 ? "entry" : "entries"}; their dependency sizes are approximate (${approximateRows.map((row) => row.entry).join(", ")}).`, ANSI.yellow));
 	console.log("");
 	if (actionRows.length > 0) {
 		console.log(bold("Agent queue (run top-down):"));