kitcn 0.27.2 → 0.27.4

package/CHANGELOG.md

@@ -1,5 +1,50 @@
 # 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
+
+- [#398](https://github.com/udecode/kitcn/pull/398) [`71158af`](https://github.com/udecode/kitcn/commit/71158af254e97942d382c9b87f736466fb2fbdbd) Thanks [@MikeyZhang75](https://github.com/MikeyZhang75)! - ## Patches
+
+  - Fix `aggregateBackfill` cutting an in-progress clear short when the same run
+    also sees a changed metric definition. A `CLEARING` index now finishes draining
+    before it moves to `BUILDING`, which is what `resume` already documented, and
+    it applies to `aggregateIndex` and `rankIndex` alike. Previously a metric or
+    sum change landing while `kitcn aggregate rebuild` was still draining could
+    abandon the rebuild halfway and still report `READY`, leaving `count()`,
+    `aggregate()` and `rank()` answering from state no document backs.
+  - Refuse to advance an index out of `CLEARING` while any of its stored state
+    survives. The backfill now fails loudly instead of rebuilding on top of a
+    half-drained index and serving numbers that are quietly wrong.
+
 ## 0.27.2
 
 ### 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-ChMQ575O.js";
+import { C as ConvexNumberBuilderInitial, E as ConvexIdBuilderInitial, N as ConvexCustomBuilderInitial } from "../where-clause-compiler-DAPEBp1y.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-BEc4d98x.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-BEc4d98x.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";
@@ -134,8 +134,8 @@ declare const adapterArgsValidator: convex_values0.VObject<{
   limit?: number | undefined;
   offset?: number | undefined;
   sortBy?: {
-    field: string;
     direction: "asc" | "desc";
+    field: string;
   } | undefined;
   model: string;
 }, {
@@ -144,12 +144,12 @@ 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<{
-    field: string;
     direction: "asc" | "desc";
+    field: string;
   } | 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", "field" | "direction">;
+  }, "optional", "direction" | "field">;
   where: convex_values0.VArray<{
     mode?: "sensitive" | "insensitive" | undefined;
     connector?: "AND" | "OR" | undefined;
@@ -169,7 +169,7 @@ declare const adapterArgsValidator: convex_values0.VObject<{
     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" | "connector" | "field" | "operator">, "optional">;
-}, "required", "model" | "select" | "where" | "limit" | "offset" | "sortBy" | "sortBy.field" | "sortBy.direction">;
+}, "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-BEc4d98x.d.ts → generated-contract-disabled-SzH57bhp.d.ts}

@@ -235,8 +235,8 @@ declare const createApi: <Schema extends SchemaDefinition<any, any>, DataModel e
     limit?: number | undefined;
     offset?: number | undefined;
     sortBy?: {
-      field: string;
       direction: "asc" | "desc";
+      field: string;
     } | undefined;
     model: string;
     paginationOpts: {

package/dist/orm/aggregate-index/index.js

@@ -1,6 +1,6 @@
 import { t as DirectAggregate } from "../../runtime-CcOvOf4K.js";
 import { a as Columns } from "../../table-CX2lnX7e.js";
-import { Y as normalizeTemporalComparableValue, bt as PUBLIC_CREATED_AT_FIELD, c as AGGREGATE_ERROR, f as createError, i as AGGREGATE_STATE_TABLE, l as COUNT_ERROR, lt as mapWithConcurrency, n as AGGREGATE_EXTREMA_TABLE, o as getAggregateIndexDefinitions, r as AGGREGATE_MEMBER_TABLE, s as getRankIndexDefinitions, t as AGGREGATE_BUCKET_TABLE, xt as usesSystemCreatedAtAlias, yt as INTERNAL_CREATION_TIME_FIELD } from "../../schema-e0wbZ_Ax.js";
+import { Ct as usesSystemCreatedAtAlias, St as PUBLIC_CREATED_AT_FIELD, Z as normalizeTemporalComparableValue, a as AGGREGATE_STATE_TABLE, c as getAggregateIndexDefinitions, d as COUNT_ERROR, dt as mapWithConcurrency, i as AGGREGATE_RANK_TREE_TABLE, l as getRankIndexDefinitions, m as createError, n as AGGREGATE_EXTREMA_TABLE, r as AGGREGATE_MEMBER_TABLE, s as rankAggregateName, t as AGGREGATE_BUCKET_TABLE, u as AGGREGATE_ERROR, xt as INTERNAL_CREATION_TIME_FIELD } from "../../schema-C5WWEqsj.js";
 
 //#region src/orm/aggregate-index/runtime.ts
 const UNDEFINED_SENTINEL = "__kitcnUndefined";
@@ -1256,6 +1256,18 @@ const assertAggregateIndexesWritable = async (db, tableName, metricIndexNames, r
 	const indexType = blockingState.kind === AGGREGATE_STATE_KIND_RANK ? "rankIndex" : "aggregateIndex";
 	throw createError(blockingState.kind === AGGREGATE_STATE_KIND_RANK ? "RANK_INDEX_BUILDING" : AGGREGATE_ERROR.INDEX_BUILDING, `${indexType} '${tableName}.${blockingState.indexName}' is CLEARING. Retry the write after aggregateBackfill reaches BUILDING or READY.`);
 };
+/**
+* Read-only mirror of the emptiness checks the clear chunks drive to
+* completion. `clearCountIndexChunk` and `clearRankIndexChunk` report `done`
+* from the same conditions, so this is what "the clear finished" means without
+* writing anything.
+*/
+const isIndexStateDrained = async (db, kind, tableName, indexName) => {
+	if (await db.query(AGGREGATE_MEMBER_TABLE).withIndex("by_kind_table_index", (q) => q.eq("kind", kind).eq("tableKey", tableName).eq("indexName", indexName)).first()) return false;
+	if (kind === AGGREGATE_STATE_KIND_RANK) return await db.query(AGGREGATE_RANK_TREE_TABLE).withIndex("by_aggregate_name", (q) => q.eq("aggregateName", rankAggregateName(tableName, indexName))).first() === null;
+	const [bucket, extrema] = await Promise.all([db.query(AGGREGATE_BUCKET_TABLE).withIndex("by_table_index", (q) => q.eq("tableKey", tableName).eq("indexName", indexName)).first(), db.query(AGGREGATE_EXTREMA_TABLE).withIndex("by_table_index", (q) => q.eq("tableKey", tableName).eq("indexName", indexName)).first()]);
+	return bucket === null && extrema === null;
+};
 const setCountState = async (db, nextState, kind = AGGREGATE_STATE_KIND_METRIC) => {
 	const existing = await getCountState(db, nextState.tableName, nextState.indexName, kind);
 	const payload = {
@@ -1276,6 +1288,10 @@ const setCountState = async (db, nextState, kind = AGGREGATE_STATE_KIND_METRIC)
 		await db.insert(AGGREGATE_STATE_TABLE, payload);
 		return;
 	}
+	if (existing.status === COUNT_STATUS_CLEARING && payload.status !== COUNT_STATUS_CLEARING && !await isIndexStateDrained(db, kind, nextState.tableName, nextState.indexName)) {
+		const indexType = kind === AGGREGATE_STATE_KIND_RANK ? "rankIndex" : "aggregateIndex";
+		throw new Error(`${indexType} '${nextState.tableName}.${nextState.indexName}' is CLEARING with stored state left; refusing to move it to ${payload.status}. Finish the clear before advancing the index.`);
+	}
 	await db.patch(AGGREGATE_STATE_TABLE, existing._id, payload);
 };
 const setCountStateError = async (db, tableName, indexName, error, kind = AGGREGATE_STATE_KIND_METRIC) => {
@@ -1377,7 +1393,6 @@ const RANK_ERROR = {
 	RLS_UNSUPPORTED: "RANK_RLS_UNSUPPORTED"
 };
 const createRankError = (code, message) => /* @__PURE__ */ new Error(`${code}: ${message}`);
-const rankAggregateName = (tableName, indexName) => `${tableName}.${indexName}`;
 const rankAggregate = (tableName, indexName) => new DirectAggregate({ name: rankAggregateName(tableName, indexName) });
 const toRankValue = (value) => {
 	if (value === null || value === void 0) return null;
@@ -1905,10 +1920,11 @@ function createCountBackfillHandlers(schema, getChunkRef) {
 						skippedReady += 1;
 						continue;
 					}
+					const cleared = existing.status === COUNT_STATUS_CLEARING ? await drainIndexClear(ctx, target.kind, target.tableName, target.indexName, batchSize, clearBudget) : true;
 					await setCountState(ctx.db, {
 						...nextStateBase,
 						kind: stateKind,
-						status: COUNT_STATUS_BUILDING,
+						status: cleared ? COUNT_STATUS_BUILDING : COUNT_STATUS_CLEARING,
 						cursor: null,
 						processed: 0,
 						startedAt: now,

package/dist/orm/index.d.ts

@@ -1,5 +1,5 @@
 import { $n as BinaryExpression, $t as OrmLifecycleOperation, A as DatabaseWithMutations, An as ConvexCheckConfig, Ar as AnyColumn, At as VectorQueryConfig, B as RlsContext, Bn as ConvexTextBuilderInitial, Br as IsUnique, Bt as RelationsBuilderColumnConfig, C as MigrationTableName, Cn as aggregateIndex, Cr as notBetween, Ct as OrderDirection, D as defineMigrationSet, Dn as uniqueIndex, Dt as ReturningResult, E as defineMigration, En as searchIndex, Er as startsWith, Et as ReturningAll, Fn as ConvexUniqueConstraintConfig, Fr as ColumnBuilderWithTableName, Ft as ExtractTablesWithRelations, Gt as defineRelations, H as EdgeMetadata, In as check, Ir as ColumnDataType, It as ManyConfig, Jt as ConvexDeletionConfig, Kt as defineRelationsPart, Ln as foreignKey, Lr as DrizzleEntity, Lt as OneConfig, M as OrmReader$1, Mn as ConvexForeignKeyConfig, Mr as ColumnBuilderBaseConfig, Mt as unsetToken, N as OrmWriter$1, Nn as ConvexUniqueConstraintBuilder, Nr as ColumnBuilderRuntimeConfig, O as detectMigrationDrift, On as vectorIndex, Or as SystemFields, Ot as ReturningSelection, Pn as ConvexUniqueConstraintBuilderOn, Pr as ColumnBuilderTypeConfig, Pt as ExtractTablesFromSchema, Qn as TableName, Qt as OrmLifecycleChange, Rn as unique, Rr as HasDefault, Rt as RelationsBuilder, S as MigrationStep, Sn as ConvexVectorIndexConfig, Sr as not, St as OrderByClause, T as buildMigrationPlan, Tn as rankIndex, Tr as or, Tt as PredicateWhereIndexConfig, U as extractRelationsConfig, Un as Brand, Ut as TableRelationalConfig, V as RlsMode, Vn as text, Vr as NotNull, Wn as Columns, Wt as TablesRelationalConfig, Xn as OrmSchemaRelations, Xt as ConvexTableWithColumns, Yn as OrmSchemaExtensions, Yt as ConvexTable, Zn as OrmSchemaTriggers, Zt as DiscriminatorBuilderConfig, _ as MigrationMigrateOne, _n as ConvexSearchIndexBuilder, _r as isNull, _t as MutationPaginateConfig, an as RlsPolicyConfig, ar as and, at as CountConfig, b as MigrationSet, bn as ConvexVectorIndexBuilder, br as lte, bt as MutationReturning, cn as RlsRole, cr as endsWith, ct as FilterOperators, d as MigrationDefinition, dn as ConvexAggregateIndexBuilder, dr as gt, dt as InferModelFromColumns, en as TableConfig, er as ExpressionVisitor, et as AggregateConfig, f as MigrationDirection, fn as ConvexAggregateIndexBuilderOn, fr as gte, ft as InferSelectModel, g as MigrationManifestEntry, gn as ConvexRankIndexBuilderOn, gr as isNotNull, gt as MutationExecutionMode, h as MigrationDriftIssue, hn as ConvexRankIndexBuilder, hr as isFieldReference, ht as MutationExecuteResult, i as OrmMigrationCapability, in as RlsPolicy, ir as UnaryExpression, it as BuildRelationResult, j as DatabaseWithQuery, jn as ConvexForeignKeyBuilder, jr as ColumnBuilder, jt as VectorSearchProvider, kn as ConvexCheckBuilder, kt as UpdateSet, ln as RlsRoleConfig, lr as eq, lt as GetColumnData, m as MigrationDocContext, mn as ConvexIndexBuilderOn, mr as inArray, mt as MutationExecuteConfig, n as OrmCapabilities, nn as deletion, nr as FilterExpression, nt as AggregateResult, on as RlsPolicyToOption, or as between, ot as CountResult, p as MigrationDoc, pn as ConvexIndexBuilder, pr as ilike, pt as InsertValue, qn as OrmSchemaExtensionTables, qt as ConvexDeletionBuilder, r as OrmCapability, rn as discriminator, rr as LogicalExpression, rt as BuildQueryResult, sn as rlsPolicy, sr as contains, st as DBQueryConfig, t as OrmAggregateCapability, tn as convexTable, tr as FieldReference, tt as AggregateFieldValue, u as MigrationAppliedState, un as rlsRole, ur as fieldRef, ut as InferInsertModel, v as MigrationPlan, vn as ConvexSearchIndexBuilderOn, vr as like, vt as MutationPaginatedResult, w as MigrationWriteMode, wn as index, wr as notInArray, wt as PaginatedResult, x as MigrationStateMap, xn as ConvexVectorIndexBuilderOn, xr as ne, xt as MutationRunMode, y as MigrationRunStatus, yn as ConvexSearchIndexConfig, yr as lt, yt as MutationResult, zn as ConvexTextBuilder, zr as IsPrimaryKey, zt as RelationsBuilderColumnBase } from "../capabilities-CLCYgRdY.js";
-import { $ as OrmClientWithApi$1, A as ConvexDateMode, B as ConvexBytesBuilderInitial, C as ConvexNumberBuilderInitial, D as id, E as ConvexIdBuilderInitial, F as custom, G as ConvexBigIntBuilder, H as ConvexBooleanBuilder, I as json, J as CreateOrmOptions, K as ConvexBigIntBuilderInitial, L as objectOf, M as ConvexCustomBuilder, N as ConvexCustomBuilderInitial, O as ConvexDateBuilder, P as arrayOf, Q as OrmClientBase$1, R as unionOf, S as ConvexNumberBuilder, St as defineTriggers, T as ConvexIdBuilder, U as ConvexBooleanBuilderInitial, V as bytes, W as boolean, X as GenericOrmCtx$1, Y as GenericOrm$1, Z as OrmApiResult, _ as ConvexTimestampMode, _t as OrmBeforeResult, a as requireSchemaRelations, at as ScheduledMutationBatchArgs, b as ConvexTextEnumBuilderInitial, bt as OrmTriggerContext, c as TableConfigResult, ct as scheduledDeleteFactory, d as OrmNotFoundError, et as OrmFunctions, f as ConvexVectorBuilder, g as ConvexTimestampBuilderInitial, gt as defineSchemaExtension, h as ConvexTimestampBuilder, ht as SchemaExtension, i as getSchemaTriggers, it as createOrm, j as date, k as ConvexDateBuilderInitial, l as getTableColumns, m as vector, n as defineSchema, nt as OrmWriterCtx, o as asc, ot as scheduledMutationBatchFactory, p as ConvexVectorBuilderInitial, q as bigint, r as getSchemaRelations, rt as ResolveOrmSchema, s as desc, st as ScheduledDeleteArgs, t as WhereClauseResult, tt as OrmReaderCtx, u as getTableConfig, v as timestamp, vt as OrmTableTriggers, w as integer, x as textEnum, xt as OrmTriggers, y as ConvexTextEnumBuilder, yt as OrmTriggerChange, z as ConvexBytesBuilder } from "../where-clause-compiler-ChMQ575O.js";
+import { $ as OrmClientWithApi$1, A as ConvexDateMode, B as ConvexBytesBuilderInitial, C as ConvexNumberBuilderInitial, D as id, E as ConvexIdBuilderInitial, F as custom, G as ConvexBigIntBuilder, H as ConvexBooleanBuilder, I as json, J as CreateOrmOptions, K as ConvexBigIntBuilderInitial, L as objectOf, M as ConvexCustomBuilder, N as ConvexCustomBuilderInitial, O as ConvexDateBuilder, P as arrayOf, Q as OrmClientBase$1, R as unionOf, S as ConvexNumberBuilder, St as defineTriggers, T as ConvexIdBuilder, U as ConvexBooleanBuilderInitial, V as bytes, W as boolean, X as GenericOrmCtx$1, Y as GenericOrm$1, Z as OrmApiResult, _ as ConvexTimestampMode, _t as OrmBeforeResult, a as requireSchemaRelations, at as ScheduledMutationBatchArgs, b as ConvexTextEnumBuilderInitial, bt as OrmTriggerContext, c as TableConfigResult, ct as scheduledDeleteFactory, d as OrmNotFoundError, et as OrmFunctions, f as ConvexVectorBuilder, g as ConvexTimestampBuilderInitial, gt as defineSchemaExtension, h as ConvexTimestampBuilder, ht as SchemaExtension, i as getSchemaTriggers, it as createOrm, j as date, k as ConvexDateBuilderInitial, l as getTableColumns, m as vector, n as defineSchema, nt as OrmWriterCtx, o as asc, ot as scheduledMutationBatchFactory, p as ConvexVectorBuilderInitial, q as bigint, r as getSchemaRelations, rt as ResolveOrmSchema, s as desc, st as ScheduledDeleteArgs, t as WhereClauseResult, tt as OrmReaderCtx, u as getTableConfig, v as timestamp, vt as OrmTableTriggers, w as integer, x as textEnum, xt as OrmTriggers, y as ConvexTextEnumBuilder, yt as OrmTriggerChange, z as ConvexBytesBuilder } from "../where-clause-compiler-DAPEBp1y.js";
 import { i as pretendRequired, n as deprecated, r as pretend } from "../validators-wOIjhkfN.js";
 import { a as QueryCtxWithPreferredOrmQueryTable, i as QueryCtxWithOrmQueryTable, n as LookupByIdResultByCtx, o as getByIdWithOrmQueryFallback, r as QueryCtxWithOptionalOrmQueryTable, t as DocByCtx } from "../query-context-DJONf8X5.js";
 import { DefineSchemaOptions, GenericDatabaseReader, GenericDatabaseWriter, GenericSchema, SchemaDefinition } from "convex/server";

package/dist/orm/index.js

@@ -4,7 +4,7 @@ import { a as pretendRequired, i as pretend, n as deprecated } from "../validato
 import { t as id } from "../id-CuSfWa5q.js";
 import { A as or, C as matchLikePattern, D as notIlike, E as notBetween, O as notInArray, S as lte, T as not, _ as isFieldReference, a as between, b as like, c as endsWith, d as filterValueInList, f as filterValuesEqual, g as inArray, h as ilike, i as arrayOverlaps, j as startsWith, k as notLike, l as eq, m as gte, n as arrayContained, o as column, p as gt, r as arrayContains, s as contains, t as and, u as fieldRef, v as isNotNull, w as ne, x as lt, y as isNull } from "../filter-expression-Dydt8wS0.js";
 import { a as indexKeyWithinBounds, c as streamIndexRange, i as getIndexFields, l as isUnsetToken, n as EmptyStream, o as mergedStream, r as QueryStream, s as stream, t as getByIdWithOrmQueryFallback, u as unsetToken } from "../query-context-DOm5Xm3H.js";
-import { $ as serializeFilterExpression, A as ensureNonNullValues, B as getMutationExecutionMode, C as deserializeFilterExpression, D as enforcePolymorphicWrite, E as enforceForeignKeys, F as getChecks, G as getUniqueIndexes, H as getTableColumns$2, I as getColumnName$1, J as normalizeDateFieldsForWrite, K as hardDeleteRow, L as getForeignKeys, M as evaluateCheckConstraintTriState, N as evaluateFilter, O as enforceUniqueIndexes, P as extractPrimaryIdLookup, Q as selectReturningRowWithHydration, R as getMutationAsyncDelayMs, S as decodeUndefinedDeep, T as enforceCheckConstraints, U as getTableDeleteConfig, V as getOrmContext, W as getTableName, X as patchReferencingRows, Y as normalizeTemporalComparableValue, Z as resolveOrmRuntimeDefaults, _ as applyIncomingForeignKeyActionsOnUpdate, _t as resolveIndexOrderPushdown, a as aggregateExtension, at as markLifecycleHookedTables, b as collectMutationRowsBounded, bt as PUBLIC_CREATED_AT_FIELD, c as AGGREGATE_ERROR, ct as isConvexEnforceableFilter, d as createCountError, dt as findRelationIndex, et as softDeleteRow, ft as findSearchIndexByName, g as applyIncomingForeignKeyActionsOnDelete, gt as getRankIndexes, h as applyDefaults, ht as getIndexes, it as hasLifecycleHooks, j as ensureNullableColumns, k as ensureDefaultColumns, l as COUNT_ERROR, lt as mapWithConcurrency, m as ensureCountAllowedForRls, mt as getAggregateIndexes, nt as takeRowsWithinByteBudget, o as getAggregateIndexDefinitions, ot as compileConvexFilter, p as ensureAggregateAllowedForRls, pt as findVectorIndexByName, q as hydrateDateFieldsForRead, rt as toConvexFilter, s as getRankIndexDefinitions, st as convexAnd, tt as splitReturningSelection, u as createAggregateError, ut as findIndexForColumns, v as buildForeignKeyGraph, vt as CREATED_AT_MIGRATION_MESSAGE, w as encodeUndefinedDeep, x as collectPrimaryIdLookupRows, xt as usesSystemCreatedAtAlias, y as canUsePrimaryIdLookupCursor, yt as INTERNAL_CREATION_TIME_FIELD, z as getMutationCollectionLimits } from "../schema-e0wbZ_Ax.js";
+import { $ as resolveOrmRuntimeDefaults, A as enforceUniqueIndexes, B as getMutationAsyncDelayMs, C as collectPrimaryIdLookupRows, Ct as usesSystemCreatedAtAlias, D as enforceCheckConstraints, E as encodeUndefinedDeep, F as evaluateFilter, G as getTableDeleteConfig, H as getMutationExecutionMode, I as extractPrimaryIdLookup, J as hardDeleteRow, K as getTableName, L as getChecks, M as ensureNonNullValues, N as ensureNullableColumns, O as enforceForeignKeys, P as evaluateCheckConstraintTriState, Q as patchReferencingRows, R as getColumnName$1, S as collectMutationRowsBounded, St as PUBLIC_CREATED_AT_FIELD, T as deserializeFilterExpression, U as getOrmContext, V as getMutationCollectionLimits, W as getTableColumns$2, X as normalizeDateFieldsForWrite, Y as hydrateDateFieldsForRead, Z as normalizeTemporalComparableValue, _ as applyDefaults, _t as getIndexes, at as toConvexFilter, b as buildForeignKeyGraph, bt as CREATED_AT_MIGRATION_MESSAGE, c as getAggregateIndexDefinitions, ct as compileConvexFilter, d as COUNT_ERROR, dt as mapWithConcurrency, et as selectReturningRowWithHydration, f as createAggregateError, ft as findIndexForColumns, g as ensureCountAllowedForRls, gt as getAggregateIndexes, h as ensureAggregateAllowedForRls, ht as findVectorIndexByName, it as takeRowsWithinByteBudget, j as ensureDefaultColumns, k as enforcePolymorphicWrite, l as getRankIndexDefinitions, lt as convexAnd, mt as findSearchIndexByName, nt as softDeleteRow, o as aggregateExtension, ot as hasLifecycleHooks, p as createCountError, pt as findRelationIndex, q as getUniqueIndexes, rt as splitReturningSelection, st as markLifecycleHookedTables, tt as serializeFilterExpression, u as AGGREGATE_ERROR, ut as isConvexEnforceableFilter, v as applyIncomingForeignKeyActionsOnDelete, vt as getRankIndexes, w as decodeUndefinedDeep, x as canUsePrimaryIdLookupCursor, xt as INTERNAL_CREATION_TIME_FIELD, y as applyIncomingForeignKeyActionsOnUpdate, yt as resolveIndexOrderPushdown, z as getForeignKeys } from "../schema-C5WWEqsj.js";
 import { t as defineSchemaExtension } from "../extensions-Blzsyekm.js";
 import { compareValues, v } from "convex/values";
 import { defineSchema as defineSchema$1, internalActionGeneric, internalMutationGeneric } from "convex/server";

package/dist/orm/migrations/index.d.ts

@@ -1,3 +1,3 @@
 import { C as MigrationTableName, D as defineMigrationSet, E as defineMigration, O as detectMigrationDrift, S as MigrationStep, T as buildMigrationPlan, _ as MigrationMigrateOne, a as MigrationCancelArgs, b as MigrationSet, c as MigrationStatusArgs, d as MigrationDefinition, f as MigrationDirection, g as MigrationManifestEntry, h as MigrationDriftIssue, l as createMigrationHandlers, m as MigrationDocContext, o as MigrationRunArgs, p as MigrationDoc, s as MigrationRunChunkArgs, u as MigrationAppliedState, v as MigrationPlan, w as MigrationWriteMode, x as MigrationStateMap, y as MigrationRunStatus } from "../../capabilities-CLCYgRdY.js";
-import { Ct as migrationCapability, dt as MIGRATION_STORAGE_TABLE_NAMES, ft as injectMigrationStorageTables, lt as MIGRATION_RUN_TABLE, mt as migrationStorageTables, pt as migrationExtension, ut as MIGRATION_STATE_TABLE } from "../../where-clause-compiler-ChMQ575O.js";
+import { Ct as migrationCapability, dt as MIGRATION_STORAGE_TABLE_NAMES, ft as injectMigrationStorageTables, lt as MIGRATION_RUN_TABLE, mt as migrationStorageTables, pt as migrationExtension, ut as MIGRATION_STATE_TABLE } from "../../where-clause-compiler-DAPEBp1y.js";
 export { MIGRATION_RUN_TABLE, MIGRATION_STATE_TABLE, MIGRATION_STORAGE_TABLE_NAMES, type MigrationAppliedState, type MigrationCancelArgs, type MigrationDefinition, type MigrationDirection, type MigrationDoc, type MigrationDocContext, type MigrationDriftIssue, type MigrationManifestEntry, type MigrationMigrateOne, type MigrationPlan, type MigrationRunArgs, type MigrationRunChunkArgs, type MigrationRunStatus, type MigrationSet, type MigrationStateMap, type MigrationStatusArgs, type MigrationStep, type MigrationTableName, type MigrationWriteMode, buildMigrationPlan, createMigrationHandlers, defineMigration, defineMigrationSet, detectMigrationDrift, injectMigrationStorageTables, migrationCapability, migrationExtension, migrationStorageTables };

package/dist/{schema-e0wbZ_Ax.js → schema-C5WWEqsj.js}

@@ -1394,6 +1394,12 @@ const AGGREGATE_EXTREMA_TABLE = "aggregate_extrema";
 const AGGREGATE_RANK_TREE_TABLE = "aggregate_rank_tree";
 const AGGREGATE_RANK_NODE_TABLE = "aggregate_rank_node";
 const AGGREGATE_STATE_TABLE = "aggregate_state";
+/**
+* Partition key a rank index's btree rows are stored under. Lives next to the
+* table names because it is how `AGGREGATE_RANK_TREE_TABLE` is addressed, and
+* both the rank runtime and the state machine have to agree on it.
+*/
+const rankAggregateName = (tableName, indexName) => `${tableName}.${indexName}`;
 const countBucketTable = convexTable(AGGREGATE_BUCKET_TABLE, {
 	tableKey: text().notNull(),
 	indexName: text().notNull(),
@@ -1483,4 +1489,4 @@ function aggregateExtension() {
 }
 
 //#endregion
-export { serializeFilterExpression as $, ensureNonNullValues as A, getMutationExecutionMode as B, deserializeFilterExpression as C, enforcePolymorphicWrite as D, enforceForeignKeys as E, getChecks as F, getUniqueIndexes as G, getTableColumns as H, getColumnName as I, normalizeDateFieldsForWrite as J, hardDeleteRow as K, getForeignKeys as L, evaluateCheckConstraintTriState as M, evaluateFilter as N, enforceUniqueIndexes as O, extractPrimaryIdLookup as P, selectReturningRowWithHydration as Q, getMutationAsyncDelayMs as R, decodeUndefinedDeep as S, enforceCheckConstraints as T, getTableDeleteConfig as U, getOrmContext as V, getTableName as W, patchReferencingRows as X, normalizeTemporalComparableValue as Y, resolveOrmRuntimeDefaults as Z, applyIncomingForeignKeyActionsOnUpdate as _, resolveIndexOrderPushdown as _t, aggregateExtension as a, markLifecycleHookedTables as at, collectMutationRowsBounded as b, PUBLIC_CREATED_AT_FIELD as bt, AGGREGATE_ERROR as c, isConvexEnforceableFilter as ct, createCountError as d, findRelationIndex as dt, softDeleteRow as et, createError as f, findSearchIndexByName as ft, applyIncomingForeignKeyActionsOnDelete as g, getRankIndexes as gt, applyDefaults as h, getIndexes as ht, AGGREGATE_STATE_TABLE as i, hasLifecycleHooks as it, ensureNullableColumns as j, ensureDefaultColumns as k, COUNT_ERROR as l, mapWithConcurrency as lt, ensureCountAllowedForRls as m, getAggregateIndexes as mt, AGGREGATE_EXTREMA_TABLE as n, takeRowsWithinByteBudget as nt, getAggregateIndexDefinitions as o, compileConvexFilter as ot, ensureAggregateAllowedForRls as p, findVectorIndexByName as pt, hydrateDateFieldsForRead as q, AGGREGATE_MEMBER_TABLE as r, toConvexFilter as rt, getRankIndexDefinitions as s, convexAnd as st, AGGREGATE_BUCKET_TABLE as t, splitReturningSelection as tt, createAggregateError as u, findIndexForColumns as ut, buildForeignKeyGraph as v, CREATED_AT_MIGRATION_MESSAGE as vt, encodeUndefinedDeep as w, collectPrimaryIdLookupRows as x, usesSystemCreatedAtAlias as xt, canUsePrimaryIdLookupCursor as y, INTERNAL_CREATION_TIME_FIELD as yt, getMutationCollectionLimits as z };
+export { resolveOrmRuntimeDefaults as $, enforceUniqueIndexes as A, getMutationAsyncDelayMs as B, collectPrimaryIdLookupRows as C, usesSystemCreatedAtAlias as Ct, enforceCheckConstraints as D, encodeUndefinedDeep as E, evaluateFilter as F, getTableDeleteConfig as G, getMutationExecutionMode as H, extractPrimaryIdLookup as I, hardDeleteRow as J, getTableName as K, getChecks as L, ensureNonNullValues as M, ensureNullableColumns as N, enforceForeignKeys as O, evaluateCheckConstraintTriState as P, patchReferencingRows as Q, getColumnName as R, collectMutationRowsBounded as S, PUBLIC_CREATED_AT_FIELD as St, deserializeFilterExpression as T, getOrmContext as U, getMutationCollectionLimits as V, getTableColumns as W, normalizeDateFieldsForWrite as X, hydrateDateFieldsForRead as Y, normalizeTemporalComparableValue as Z, applyDefaults as _, getIndexes as _t, AGGREGATE_STATE_TABLE as a, toConvexFilter as at, buildForeignKeyGraph as b, CREATED_AT_MIGRATION_MESSAGE as bt, getAggregateIndexDefinitions as c, compileConvexFilter as ct, COUNT_ERROR as d, mapWithConcurrency as dt, selectReturningRowWithHydration as et, createAggregateError as f, findIndexForColumns as ft, ensureCountAllowedForRls as g, getAggregateIndexes as gt, ensureAggregateAllowedForRls as h, findVectorIndexByName as ht, AGGREGATE_RANK_TREE_TABLE as i, takeRowsWithinByteBudget as it, ensureDefaultColumns as j, enforcePolymorphicWrite as k, getRankIndexDefinitions as l, convexAnd as lt, createError as m, findSearchIndexByName as mt, AGGREGATE_EXTREMA_TABLE as n, softDeleteRow as nt, aggregateExtension as o, hasLifecycleHooks as ot, createCountError as p, findRelationIndex as pt, getUniqueIndexes as q, AGGREGATE_MEMBER_TABLE as r, splitReturningSelection as rt, rankAggregateName as s, markLifecycleHookedTables as st, AGGREGATE_BUCKET_TABLE as t, serializeFilterExpression as tt, AGGREGATE_ERROR as u, isConvexEnforceableFilter as ut, applyIncomingForeignKeyActionsOnDelete as v, getRankIndexes as vt, decodeUndefinedDeep as w, canUsePrimaryIdLookupCursor as x, INTERNAL_CREATION_TIME_FIELD as xt, applyIncomingForeignKeyActionsOnUpdate as y, resolveIndexOrderPushdown as yt, getForeignKeys as z };

package/dist/{where-clause-compiler-ChMQ575O.d.ts → where-clause-compiler-DAPEBp1y.d.ts}

@@ -102,25 +102,20 @@ declare const migrationStorageTables: {
           fieldName: "status";
         };
       };
-      cursor: ConvexTextBuilderInitial<""> & {
+      migrationId: ConvexTextBuilderInitial<""> & {
         _: {
-          tableName: "migration_state";
+          notNull: true;
         };
       } & {
-        _: {
-          fieldName: "cursor";
-        };
-      };
-      direction: ConvexTextBuilderInitial<""> & {
         _: {
           tableName: "migration_state";
         };
       } & {
         _: {
-          fieldName: "direction";
+          fieldName: "migrationId";
         };
       };
-      updatedAt: ConvexNumberBuilderInitial<""> & {
+      checksum: ConvexTextBuilderInitial<""> & {
         _: {
           notNull: true;
         };
@@ -130,10 +125,10 @@ declare const migrationStorageTables: {
         };
       } & {
         _: {
-          fieldName: "updatedAt";
+          fieldName: "checksum";
         };
       };
-      migrationId: ConvexTextBuilderInitial<""> & {
+      applied: ConvexBooleanBuilderInitial<""> & {
         _: {
           notNull: true;
         };
@@ -143,42 +138,34 @@ declare const migrationStorageTables: {
         };
       } & {
         _: {
-          fieldName: "migrationId";
+          fieldName: "applied";
         };
       };
-      checksum: ConvexTextBuilderInitial<""> & {
-        _: {
-          notNull: true;
-        };
-      } & {
+      direction: ConvexTextBuilderInitial<""> & {
         _: {
           tableName: "migration_state";
         };
       } & {
         _: {
-          fieldName: "checksum";
+          fieldName: "direction";
         };
       };
-      applied: ConvexBooleanBuilderInitial<""> & {
-        _: {
-          notNull: true;
-        };
-      } & {
+      runId: ConvexTextBuilderInitial<""> & {
         _: {
           tableName: "migration_state";
         };
       } & {
         _: {
-          fieldName: "applied";
+          fieldName: "runId";
         };
       };
-      runId: ConvexTextBuilderInitial<""> & {
+      cursor: ConvexTextBuilderInitial<""> & {
         _: {
           tableName: "migration_state";
         };
       } & {
         _: {
-          fieldName: "runId";
+          fieldName: "cursor";
         };
       };
       processed: ConvexNumberBuilderInitial<""> & {
@@ -203,6 +190,19 @@ declare const migrationStorageTables: {
           fieldName: "startedAt";
         };
       };
+      updatedAt: ConvexNumberBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "migration_state";
+        };
+      } & {
+        _: {
+          fieldName: "updatedAt";
+        };
+      };
       completedAt: ConvexNumberBuilderInitial<""> & {
         _: {
           tableName: "migration_state";
@@ -269,7 +269,7 @@ declare const migrationStorageTables: {
           fieldName: "direction";
         };
       };
-      updatedAt: ConvexNumberBuilderInitial<""> & {
+      runId: ConvexTextBuilderInitial<""> & {
         _: {
           notNull: true;
         };
@@ -279,10 +279,10 @@ declare const migrationStorageTables: {
         };
       } & {
         _: {
-          fieldName: "updatedAt";
+          fieldName: "runId";
         };
       };
-      runId: ConvexTextBuilderInitial<""> & {
+      startedAt: ConvexNumberBuilderInitial<""> & {
         _: {
           notNull: true;
         };
@@ -292,10 +292,10 @@ declare const migrationStorageTables: {
         };
       } & {
         _: {
-          fieldName: "runId";
+          fieldName: "startedAt";
         };
       };
-      startedAt: ConvexNumberBuilderInitial<""> & {
+      updatedAt: ConvexNumberBuilderInitial<""> & {
         _: {
           notNull: true;
         };
@@ -305,7 +305,7 @@ declare const migrationStorageTables: {
         };
       } & {
         _: {
-          fieldName: "startedAt";
+          fieldName: "updatedAt";
         };
       };
       completedAt: ConvexNumberBuilderInitial<""> & {
@@ -1008,7 +1008,7 @@ declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
   readonly aggregate_bucket: ConvexTableWithColumns<{
     name: "aggregate_bucket";
     columns: {
-      count: ConvexNumberBuilderInitial<""> & {
+      updatedAt: ConvexNumberBuilderInitial<""> & {
         _: {
           notNull: true;
         };
@@ -1018,10 +1018,10 @@ declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
         };
       } & {
         _: {
-          fieldName: "count";
+          fieldName: "updatedAt";
         };
       };
-      updatedAt: ConvexNumberBuilderInitial<""> & {
+      count: ConvexNumberBuilderInitial<""> & {
         _: {
           notNull: true;
         };
@@ -1031,10 +1031,10 @@ declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
         };
       } & {
         _: {
-          fieldName: "updatedAt";
+          fieldName: "count";
         };
       };
-      tableKey: ConvexTextBuilderInitial<""> & {
+      indexName: ConvexTextBuilderInitial<""> & {
         _: {
           notNull: true;
         };
@@ -1044,10 +1044,10 @@ declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
         };
       } & {
         _: {
-          fieldName: "tableKey";
+          fieldName: "indexName";
         };
       };
-      indexName: ConvexTextBuilderInitial<""> & {
+      tableKey: ConvexTextBuilderInitial<""> & {
         _: {
           notNull: true;
         };
@@ -1057,7 +1057,7 @@ declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
         };
       } & {
         _: {
-          fieldName: "indexName";
+          fieldName: "tableKey";
         };
       };
       keyHash: ConvexTextBuilderInitial<""> & {
@@ -1133,7 +1133,7 @@ declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
   readonly aggregate_member: ConvexTableWithColumns<{
     name: "aggregate_member";
     columns: {
-      kind: ConvexTextBuilderInitial<""> & {
+      updatedAt: ConvexNumberBuilderInitial<""> & {
         _: {
           notNull: true;
         };
@@ -1143,10 +1143,10 @@ declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
         };
       } & {
         _: {
-          fieldName: "kind";
+          fieldName: "updatedAt";
         };
       };
-      updatedAt: ConvexNumberBuilderInitial<""> & {
+      kind: ConvexTextBuilderInitial<""> & {
         _: {
           notNull: true;
         };
@@ -1156,10 +1156,10 @@ declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
         };
       } & {
         _: {
-          fieldName: "updatedAt";
+          fieldName: "kind";
         };
       };
-      tableKey: ConvexTextBuilderInitial<""> & {
+      indexName: ConvexTextBuilderInitial<""> & {
         _: {
           notNull: true;
         };
@@ -1169,10 +1169,10 @@ declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
         };
       } & {
         _: {
-          fieldName: "tableKey";
+          fieldName: "indexName";
         };
       };
-      indexName: ConvexTextBuilderInitial<""> & {
+      tableKey: ConvexTextBuilderInitial<""> & {
         _: {
           notNull: true;
         };
@@ -1182,7 +1182,7 @@ declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
         };
       } & {
         _: {
-          fieldName: "indexName";
+          fieldName: "tableKey";
         };
       };
       keyHash: ConvexTextBuilderInitial<""> & {
@@ -1323,11 +1323,7 @@ declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
   readonly aggregate_extrema: ConvexTableWithColumns<{
     name: "aggregate_extrema";
     columns: {
-      value: ConvexCustomBuilderInitial<"", convex_values0.VAny<any, "required", string>> & {
-        _: {
-          $type: convex_values0.Value;
-        };
-      } & {
+      updatedAt: ConvexNumberBuilderInitial<""> & {
         _: {
           notNull: true;
         };
@@ -1337,10 +1333,14 @@ declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
         };
       } & {
         _: {
-          fieldName: "value";
+          fieldName: "updatedAt";
         };
       };
-      count: ConvexNumberBuilderInitial<""> & {
+      value: ConvexCustomBuilderInitial<"", convex_values0.VAny<any, "required", string>> & {
+        _: {
+          $type: convex_values0.Value;
+        };
+      } & {
         _: {
           notNull: true;
         };
@@ -1350,10 +1350,10 @@ declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
         };
       } & {
         _: {
-          fieldName: "count";
+          fieldName: "value";
         };
       };
-      updatedAt: ConvexNumberBuilderInitial<""> & {
+      count: ConvexNumberBuilderInitial<""> & {
         _: {
           notNull: true;
         };
@@ -1363,10 +1363,10 @@ declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
         };
       } & {
         _: {
-          fieldName: "updatedAt";
+          fieldName: "count";
         };
       };
-      tableKey: ConvexTextBuilderInitial<""> & {
+      indexName: ConvexTextBuilderInitial<""> & {
         _: {
           notNull: true;
         };
@@ -1376,10 +1376,10 @@ declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
         };
       } & {
         _: {
-          fieldName: "tableKey";
+          fieldName: "indexName";
         };
       };
-      indexName: ConvexTextBuilderInitial<""> & {
+      tableKey: ConvexTextBuilderInitial<""> & {
         _: {
           notNull: true;
         };
@@ -1389,7 +1389,7 @@ declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
         };
       } & {
         _: {
-          fieldName: "indexName";
+          fieldName: "tableKey";
         };
       };
       keyHash: ConvexTextBuilderInitial<""> & {
@@ -1589,19 +1589,6 @@ declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
           fieldName: "status";
         };
       };
-      kind: ConvexTextBuilderInitial<""> & {
-        _: {
-          notNull: true;
-        };
-      } & {
-        _: {
-          tableName: "aggregate_state";
-        };
-      } & {
-        _: {
-          fieldName: "kind";
-        };
-      };
       cursor: ConvexTextBuilderInitial<""> & {
         _: {
           tableName: "aggregate_state";
@@ -1611,7 +1598,7 @@ declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
           fieldName: "cursor";
         };
       };
-      updatedAt: ConvexNumberBuilderInitial<""> & {
+      processed: ConvexNumberBuilderInitial<""> & {
         _: {
           notNull: true;
         };
@@ -1621,10 +1608,10 @@ declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
         };
       } & {
         _: {
-          fieldName: "updatedAt";
+          fieldName: "processed";
         };
       };
-      processed: ConvexNumberBuilderInitial<""> & {
+      startedAt: ConvexNumberBuilderInitial<""> & {
         _: {
           notNull: true;
         };
@@ -1634,10 +1621,10 @@ declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
         };
       } & {
         _: {
-          fieldName: "processed";
+          fieldName: "startedAt";
         };
       };
-      startedAt: ConvexNumberBuilderInitial<""> & {
+      updatedAt: ConvexNumberBuilderInitial<""> & {
         _: {
           notNull: true;
         };
@@ -1647,7 +1634,7 @@ declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
         };
       } & {
         _: {
-          fieldName: "startedAt";
+          fieldName: "updatedAt";
         };
       };
       completedAt: ConvexNumberBuilderInitial<""> & {
@@ -1668,7 +1655,7 @@ declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
           fieldName: "lastError";
         };
       };
-      tableKey: ConvexTextBuilderInitial<""> & {
+      kind: ConvexTextBuilderInitial<""> & {
         _: {
           notNull: true;
         };
@@ -1678,7 +1665,7 @@ declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
         };
       } & {
         _: {
-          fieldName: "tableKey";
+          fieldName: "kind";
         };
       };
       indexName: ConvexTextBuilderInitial<""> & {
@@ -1720,6 +1707,19 @@ declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
           fieldName: "metricDefinitionHash";
         };
       };
+      tableKey: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_state";
+        };
+      } & {
+        _: {
+          fieldName: "tableKey";
+        };
+      };
     };
   }, {
     by_creation_time: ["_creationTime"];
@@ -1744,25 +1744,20 @@ declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
           fieldName: "status";
         };
       };
-      cursor: ConvexTextBuilderInitial<""> & {
+      migrationId: ConvexTextBuilderInitial<""> & {
         _: {
-          tableName: "migration_state";
+          notNull: true;
         };
       } & {
-        _: {
-          fieldName: "cursor";
-        };
-      };
-      direction: ConvexTextBuilderInitial<""> & {
         _: {
           tableName: "migration_state";
         };
       } & {
         _: {
-          fieldName: "direction";
+          fieldName: "migrationId";
         };
       };
-      updatedAt: ConvexNumberBuilderInitial<""> & {
+      checksum: ConvexTextBuilderInitial<""> & {
         _: {
           notNull: true;
         };
@@ -1772,10 +1767,10 @@ declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
         };
       } & {
         _: {
-          fieldName: "updatedAt";
+          fieldName: "checksum";
         };
       };
-      migrationId: ConvexTextBuilderInitial<""> & {
+      applied: ConvexBooleanBuilderInitial<""> & {
         _: {
           notNull: true;
         };
@@ -1785,42 +1780,34 @@ declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
         };
       } & {
         _: {
-          fieldName: "migrationId";
+          fieldName: "applied";
         };
       };
-      checksum: ConvexTextBuilderInitial<""> & {
-        _: {
-          notNull: true;
-        };
-      } & {
+      direction: ConvexTextBuilderInitial<""> & {
         _: {
           tableName: "migration_state";
         };
       } & {
         _: {
-          fieldName: "checksum";
+          fieldName: "direction";
         };
       };
-      applied: ConvexBooleanBuilderInitial<""> & {
-        _: {
-          notNull: true;
-        };
-      } & {
+      runId: ConvexTextBuilderInitial<""> & {
         _: {
           tableName: "migration_state";
         };
       } & {
         _: {
-          fieldName: "applied";
+          fieldName: "runId";
         };
       };
-      runId: ConvexTextBuilderInitial<""> & {
+      cursor: ConvexTextBuilderInitial<""> & {
         _: {
           tableName: "migration_state";
         };
       } & {
         _: {
-          fieldName: "runId";
+          fieldName: "cursor";
         };
       };
       processed: ConvexNumberBuilderInitial<""> & {
@@ -1845,6 +1832,19 @@ declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
           fieldName: "startedAt";
         };
       };
+      updatedAt: ConvexNumberBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "migration_state";
+        };
+      } & {
+        _: {
+          fieldName: "updatedAt";
+        };
+      };
       completedAt: ConvexNumberBuilderInitial<""> & {
         _: {
           tableName: "migration_state";
@@ -1911,7 +1911,7 @@ declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
           fieldName: "direction";
         };
       };
-      updatedAt: ConvexNumberBuilderInitial<""> & {
+      runId: ConvexTextBuilderInitial<""> & {
         _: {
           notNull: true;
         };
@@ -1921,10 +1921,10 @@ declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
         };
       } & {
         _: {
-          fieldName: "updatedAt";
+          fieldName: "runId";
         };
       };
-      runId: ConvexTextBuilderInitial<""> & {
+      startedAt: ConvexNumberBuilderInitial<""> & {
         _: {
           notNull: true;
         };
@@ -1934,10 +1934,10 @@ declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
         };
       } & {
         _: {
-          fieldName: "runId";
+          fieldName: "startedAt";
         };
       };
-      startedAt: ConvexNumberBuilderInitial<""> & {
+      updatedAt: ConvexNumberBuilderInitial<""> & {
         _: {
           notNull: true;
         };
@@ -1947,7 +1947,7 @@ declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
         };
       } & {
         _: {
-          fieldName: "startedAt";
+          fieldName: "updatedAt";
         };
       };
       completedAt: ConvexNumberBuilderInitial<""> & {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kitcn",
-  "version": "0.27.2",
+  "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