kitcn 0.27.3 → 0.27.4

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # kitcn
 
+## 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/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-SzH57bhp.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-SzH57bhp.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?: {
+    direction: "asc" | "desc";
+    field: string;
+  } | undefined;
   model: string;
 }, {
   limit: convex_values0.VFloat64<number | undefined, "optional">;
@@ -152,24 +152,24 @@ declare const adapterArgsValidator: convex_values0.VObject<{
   }, "optional", "direction" | "field">;
   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.direction" | "sortBy.field">;
 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/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):"));

package/dist/{generated-contract-disabled-D4mw0d-V.d.ts → generated-contract-disabled-SzH57bhp.d.ts}

@@ -183,8 +183,8 @@ declare const createApi: <Schema extends SchemaDefinition<any, any>, DataModel e
   deleteMany: convex_server0.RegisteredMutation<"internal", {
     input: {
       where?: {
-        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;
@@ -212,8 +212,8 @@ declare const createApi: <Schema extends SchemaDefinition<any, any>, DataModel e
   deleteOne: convex_server0.RegisteredMutation<"internal", {
     input: {
       where?: {
-        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;
@@ -225,19 +225,20 @@ declare const createApi: <Schema extends SchemaDefinition<any, any>, DataModel e
   }, Promise<Record<string, unknown> | undefined>>;
   findMany: convex_server0.RegisteredQuery<"internal", {
     join?: any;
-    limit?: number | undefined;
-    offset?: number | 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?: {
+      direction: "asc" | "desc";
+      field: string;
+    } | undefined;
+    model: string;
     paginationOpts: {
       id?: number;
       endCursor?: string | null;
@@ -246,15 +247,14 @@ declare const createApi: <Schema extends SchemaDefinition<any, any>, DataModel e
       numItems: number;
       cursor: string | null;
     };
-    model: string;
   }, Promise<PaginationResult<convex_server0.GenericDocument>>>;
   findOne: convex_server0.RegisteredQuery<"internal", {
     join?: any;
     select?: 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;
@@ -265,8 +265,8 @@ declare const createApi: <Schema extends SchemaDefinition<any, any>, DataModel e
   updateMany: convex_server0.RegisteredMutation<"internal", {
     input: {
       where?: {
-        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;
@@ -300,8 +300,8 @@ declare const createApi: <Schema extends SchemaDefinition<any, any>, DataModel e
   updateOne: convex_server0.RegisteredMutation<"internal", {
     input: {
       where?: {
-        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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kitcn",
-  "version": "0.27.3",
+  "version": "0.27.4",
   "description": "kitcn - React Query integration and CLI tools for Convex",
   "keywords": [
     "convex",
@@ -69,7 +69,7 @@
     "common-tags": "^1.8.2",
     "diff": "^8.0.2",
     "dotenv": "^17.3.1",
-    "esbuild": "^0.27.3",
+    "esbuild": "^0.27.7",
     "execa": "^9.6.1",
     "jiti": "^2.6.1",
     "jotai": "^2.18.0",

package/skills/kitcn/references/setup/index.md

@@ -644,6 +644,12 @@ bunx kitcn aggregate backfill --prod
 bunx kitcn analyze
 ```
 
+`kitcn analyze` ranks each Convex function by the isolate it deploys into.
+`OutMB` is that isolate's bundled size; `DepMB`/`LocMB` are the source size of
+the dependency and own-Convex files inside it; `Files` counts the files
+contributing bytes to it. A file that is imported but fully tree-shaken away is
+counted in none of them. Use `--deploy` for deployment totals instead.
+
 Concave lane:
 
 ```bash