@mulmoclaude/core 0.23.0 → 0.24.0

package/dist/{server-Q7ld-FlZ.cjs → server-CkysfLh4.cjs}

@@ -1,5 +1,5 @@
 const require_rolldown_runtime = require("./rolldown-runtime-D6vf50IK.cjs");
-const require_promptSafety = require("./promptSafety-DRd15gQ6.cjs");
+const require_promptSafety = require("./promptSafety-DI_1Rvhk.cjs");
 const require_collection_paths = require("./collection/paths.cjs");
 const require_skill_bridge_index = require("./skill-bridge/index.cjs");
 let node_path = require("node:path");
@@ -795,17 +795,18 @@ function whereFragment(cond) {
 		params: [cond.value]
 	};
 }
-/** Compile a validated query. Returns the SQL (whose FIRST placeholder is
-*  the CSV path — the executor binds it) and the where-value parameters
-*  that follow it. Callers MUST have run `CollectionQueryZ` first; this
-*  function trusts the shape (aliases already charset-checked, orderBy
-*  membership already enforced). */
-function compileCsvQuery(query, primaryKey) {
+/** Compile a validated query against `fromSql` (a table-function call
+*  whose FIRST placeholder is the source path — the executor binds it).
+*  Returns the SQL and the where-value parameters that follow the path.
+*  Callers MUST have run `CollectionQueryZ` first; this function trusts
+*  the shape (aliases already charset-checked, orderBy membership already
+*  enforced). */
+function compileQuery(query, fromSql) {
 	const groupBy = query.groupBy ?? [];
 	const aggregates = Object.entries(query.aggregates ?? {});
 	const selectList = [...groupBy.map(quoteIdent), ...aggregates.map(([alias, aggregate]) => `${aggregateExpr(aggregate)} AS ${quoteIdent(alias)}`)];
 	const where = (query.where ?? []).map(whereFragment);
-	const clauses = [`SELECT ${selectList.join(", ")}`, `FROM read_csv(${readCsvArgs(primaryKey)})`];
+	const clauses = [`SELECT ${selectList.join(", ")}`, `FROM ${fromSql}`];
 	if (where.length > 0) clauses.push(`WHERE ${where.map((fragment) => fragment.sql).join(" AND ")}`);
 	if (groupBy.length > 0) clauses.push(`GROUP BY ${groupBy.map(quoteIdent).join(", ")}`);
 	const orderBy = (query.orderBy ?? []).map((order) => quoteIdent(order.field) + (order.dir === "desc" ? " DESC" : " ASC"));
@@ -816,6 +817,21 @@ function compileCsvQuery(query, primaryKey) {
 		params: where.flatMap((fragment) => fragment.params)
 	};
 }
+/** Compile against a CSV file (the dataSource store's engine). */
+function compileCsvQuery(query, primaryKey) {
+	return compileQuery(query, `read_csv(${readCsvArgs(primaryKey)})`);
+}
+/** Compile against a JSONL file of ENRICHED records — the file-backed
+*  collections' engine (see `jsonlQuery.ts`). No VARCHAR key pin needed:
+*  enriched record ids are already strings. `sample_size=-1` makes the
+*  schema inference scan EVERY line — with the default sample, a sparse
+*  optional/derived field first appearing past the sample would not be
+*  inferred as a column and the query would binder-error on it (Codex P2
+*  on #2165). The full scan costs nothing extra here: aggregation reads
+*  the whole file anyway. */
+function compileJsonlQuery(query) {
+	return compileQuery(query, `read_json(?, format='newline_delimited', sample_size=-1)`);
+}
 //#endregion
 //#region src/collection/server/csvStore.ts
 /** `list()` row cap. Over-cap files are truncated with a warn — the v1
@@ -1136,6 +1152,74 @@ function storeFor(collection, opts = {}) {
 	};
 }
 //#endregion
+//#region src/collection/server/jsonlQuery.ts
+/** SQL semantics for an aggregate-only query over ZERO rows: one scalar
+*  row (`count` = 0, everything else NULL) — the same shape the CSV path
+*  produces for a header-only file, so callers reading `rows[0]` never
+*  break on storage kind or emptiness. A grouped query over zero rows is
+*  zero groups (`[]`), also matching SQL. Synthesized here because DuckDB
+*  has no empty file to infer a schema from. */
+function emptyCollectionResult(query) {
+	if ((query.groupBy?.length ?? 0) > 0) return [];
+	const aggregates = Object.entries(query.aggregates ?? {});
+	return [Object.fromEntries(aggregates.map(([alias, aggregate]) => [alias, aggregate.op === "count" ? 0 : null]))];
+}
+/** The SOURCE columns a query reads: groupBy columns, aggregate input
+*  columns, and where fields. (orderBy resolves to groupBy columns or
+*  aggregate ALIASES — never to a new source column — so it adds none.) */
+function referencedSourceColumns(query) {
+	const columns = new Set(query.groupBy ?? []);
+	for (const aggregate of Object.values(query.aggregates ?? {})) if (aggregate.column !== void 0) columns.add(aggregate.column);
+	for (const cond of query.where ?? []) columns.add(cond.field);
+	return [...columns];
+}
+/** Referenced columns that appear in NO row — a freshly-added optional
+*  field, or a derived field whose inputs no record has yet. DuckDB only
+*  infers columns from keys that occur in the JSONL, so without help a
+*  valid query on such a field binder-errors here while the CSV path
+*  (whose header always declares the column) returns NULLs. Padding the
+*  FIRST line with `col: null` makes the column exist (full-scan
+*  inference unions keys across lines) with matching NULL semantics. */
+function absentReferencedColumns(rows, query) {
+	const present = /* @__PURE__ */ new Set();
+	for (const row of rows) for (const key of Object.keys(row)) present.add(key);
+	return referencedSourceColumns(query).filter((column) => !present.has(column));
+}
+/** Run a validated query over enriched collection rows. */
+async function runQueryOverRows(rows, query) {
+	if (rows.length === 0) return emptyCollectionResult(query);
+	await (0, node_fs_promises.mkdir)(cacheDir(), {
+		recursive: true,
+		mode: 448
+	});
+	const jsonlPath = node_path.default.join(cacheDir(), `q-${(0, node_crypto.randomBytes)(8).toString("hex")}.jsonl`);
+	try {
+		const nullPads = Object.fromEntries(absentReferencedColumns(rows, query).map((column) => [column, null]));
+		const handle = await (0, node_fs_promises.open)(jsonlPath, "wx", 384);
+		try {
+			let first = true;
+			for (const row of rows) {
+				await handle.write(`${JSON.stringify(first ? {
+					...nullPads,
+					...row
+				} : row)}\n`);
+				first = false;
+			}
+		} finally {
+			await handle.close();
+		}
+		const { sql, params } = compileJsonlQuery(query);
+		return (await queryCsv(sql, [jsonlPath, ...params])).map((row) => Object.fromEntries(Object.entries(row).map(([key, value]) => [key, normalizeCsvValue(value)])));
+	} finally {
+		await (0, node_fs_promises.unlink)(jsonlPath).catch((err) => {
+			if (err.code !== "ENOENT") log.warn("collections", "temp JSONL cleanup failed", {
+				path: jsonlPath,
+				error: String(err)
+			});
+		});
+	}
+}
+//#endregion
 //#region src/collection/core/recordZ.ts
 /** The emptiness rule shared by `required` and the "only check present
 *  values" gate. NOT a truthiness check — `0` and `false` are filled. */
@@ -1421,6 +1505,32 @@ var WhenZ = zod.z.object({
 	field: zod.z.string().trim().min(1),
 	in: zod.z.array(zod.z.string().trim().min(1)).min(1)
 });
+var ValueRefZ = zod.z.object({
+	record: zod.z.string().trim().min(1).optional(),
+	field: zod.z.string().trim().min(1)
+});
+var WhereCondZ = zod.z.object({
+	field: zod.z.string().trim().min(1),
+	op: zod.z.enum([
+		"eq",
+		"ne",
+		"in",
+		"gt",
+		"gte",
+		"lt",
+		"lte",
+		"contains"
+	]),
+	value: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]).optional(),
+	valueFrom: ValueRefZ.optional()
+}).refine((cond) => cond.value !== void 0 !== (cond.valueFrom !== void 0), {
+	message: "a where condition must declare exactly one of `value` (a literal) or `valueFrom` (a reference to another record's field), never both or neither",
+	path: ["value"]
+}).refine((cond) => cond.value === void 0 || cond.op === "in" === Array.isArray(cond.value), {
+	message: "`in` requires an array `value` (the allowed set); every other op requires a single string `value`",
+	path: ["value"]
+});
+var WhereZ = zod.z.array(WhereCondZ);
 var fieldBase = {
 	label: zod.z.string().min(1),
 	primary: zod.z.boolean().optional(),
@@ -1631,6 +1741,30 @@ var ToggleFieldZ = zod.z.object({
 	onValue: zod.z.string().trim().min(1),
 	offValue: zod.z.string().trim().min(1)
 });
+/** A computed boolean: the record matched against a `where` predicate
+*  (the same AND-of-conditions shape `dynamicIcon` uses; evaluated by
+*  `./where`'s `matchesWhere`). Generic state summaries — isDone,
+*  isPassed, isQualified — become declared fields, so every
+*  field-driven mechanism (table cells, detail view, completion via
+*  `completionField`) picks them up without special cases. Never
+*  stored; computed by `deriveAll` on both server and client in the
+*  same saturation loop as `derived`, so a flag may read derived /
+*  rollup values — and other flags (`matchesWhere` stringifies, so
+*  `eq "true"` composes). Deliberately a STRUCTURED field, not formula
+*  syntax — the derived evaluator's no-string-literals boundary stays
+*  untouched (same reasoning as `rollup`). Cross-record
+*  `valueFrom.record` is rejected here: per-record evaluation has no
+*  `recordsById`, so it could only ever silently never-match.
+*  `where` condition fields are validated to exist by a schema-level
+*  refine below (a field can't see its siblings). */
+var FlagFieldZ = zod.z.object({
+	type: zod.z.literal("flag"),
+	...fieldBase,
+	where: WhereZ.min(1)
+}).refine((spec) => spec.where.every((cond) => cond.valueFrom?.record === void 0), {
+	message: "a flag's `where` cannot use `valueFrom.record` (cross-record references are unresolvable in per-record evaluation); use a literal `value` or a same-record `valueFrom` (field-to-field)",
+	path: ["where"]
+});
 var FieldSpecZ = zod.z.discriminatedUnion("type", [
 	ScalarFieldZ,
 	RefFieldZ,
@@ -1641,7 +1775,8 @@ var FieldSpecZ = zod.z.discriminatedUnion("type", [
 	EmbedFieldZ,
 	BacklinksFieldZ,
 	RollupFieldZ,
-	ToggleFieldZ
+	ToggleFieldZ,
+	FlagFieldZ
 ]);
 var actionBase = {
 	id: zod.z.string().trim().min(1),
@@ -1790,32 +1925,6 @@ var AgentIngestZ = zod.z.object({
 *  discovered from `<workspace>/feeds/` are REQUIRED to carry it (gated by
 *  `acceptParsedSchema`). */
 var IngestZ = zod.z.discriminatedUnion("kind", [DeclarativeIngestZ, AgentIngestZ]);
-var ValueRefZ = zod.z.object({
-	record: zod.z.string().trim().min(1).optional(),
-	field: zod.z.string().trim().min(1)
-});
-var WhereCondZ = zod.z.object({
-	field: zod.z.string().trim().min(1),
-	op: zod.z.enum([
-		"eq",
-		"ne",
-		"in",
-		"gt",
-		"gte",
-		"lt",
-		"lte",
-		"contains"
-	]),
-	value: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]).optional(),
-	valueFrom: ValueRefZ.optional()
-}).refine((cond) => cond.value !== void 0 !== (cond.valueFrom !== void 0), {
-	message: "a where condition must declare exactly one of `value` (a literal) or `valueFrom` (a reference to another record's field), never both or neither",
-	path: ["value"]
-}).refine((cond) => cond.value === void 0 || cond.op === "in" === Array.isArray(cond.value), {
-	message: "`in` requires an array `value` (the allowed set); every other op requires a single string `value`",
-	path: ["value"]
-});
-var WhereZ = zod.z.array(WhereCondZ);
 var DynamicIconSourceZ = zod.z.object({
 	collection: zod.z.string().trim().min(1),
 	from: zod.z.enum([
@@ -1910,12 +2019,12 @@ function fieldDrivenFromFieldCarried(schema) {
 *  workspace-relative and containment-checked exactly like `dataPath`. The
 *  row-id column is the schema's existing `primaryKey` — there is
 *  deliberately no second key concept here.
-*  See plans/feat-collection-csv-duckdb-source.md. */
+*  See plans/done/feat-collection-csv-duckdb-source.md. */
 var DataSourceZ = zod.z.object({
 	type: zod.z.literal("csv"),
 	path: zod.z.string().min(1)
 });
-var CollectionSchemaZ = zod.z.object({
+var BareCollectionSchemaZ = zod.z.object({
 	title: zod.z.string().min(1),
 	icon: zod.z.string().min(1),
 	dataPath: zod.z.string().min(1).optional(),
@@ -1975,8 +2084,11 @@ var CollectionSchemaZ = zod.z.object({
 }).refine((schema) => collectCurrencyFieldRefs(schema.fields).every((name) => CODE_FIELD_TYPES.has(schema.fields[name]?.type ?? "")), {
 	message: "a money field's `currencyField` must name a top-level `string`, `text`, or `enum` field that holds the currency code",
 	path: ["fields"]
-}).refine((schema) => schema.completionField === void 0 === (schema.completionDoneValues === void 0), {
-	message: "schema `completionField` and `completionDoneValues` must be declared together (both set, or both omitted)",
+}).refine((schema) => {
+	if (schema.completionField !== void 0 && schema.fields[schema.completionField]?.type === "flag") return schema.completionDoneValues === void 0;
+	return schema.completionField === void 0 === (schema.completionDoneValues === void 0);
+}, {
+	message: "schema `completionField` and `completionDoneValues` must be declared together (both set, or both omitted) — unless `completionField` names a `flag` field, in which case `completionDoneValues` must be omitted (done ⇔ the flag matches)",
 	path: ["completionField"]
 }).refine((schema) => schema.completionField === void 0 || schema.fields[schema.completionField] !== void 0, {
 	message: "schema `completionField` must name a top-level field declared in `fields`",
@@ -1987,6 +2099,22 @@ var CollectionSchemaZ = zod.z.object({
 }).refine((schema) => Object.values(schema.fields).every((field) => field.when === void 0 || schema.fields[field.when.field] !== void 0), {
 	message: "a field's `when.field` must name a top-level field declared in `fields`",
 	path: ["fields"]
+}).refine((schema) => Object.values(schema.fields).every((field) => field.type !== "flag" || field.where.every((cond) => schema.fields[cond.field] !== void 0 && (cond.valueFrom === void 0 || schema.fields[cond.valueFrom.field] !== void 0))), {
+	message: "a flag field's `where` conditions must name top-level fields declared in `fields` (both `field` and a same-record `valueFrom.field`)",
+	path: ["fields"]
+}).refine((schema) => {
+	const spec = schema.completionField === void 0 ? void 0 : schema.fields[schema.completionField];
+	if (spec?.type !== "flag") return true;
+	return spec.where.every((cond) => [cond.field, ...cond.valueFrom ? [cond.valueFrom.field] : []].every((name) => {
+		const target = schema.fields[name];
+		return target !== void 0 && !require_promptSafety.COMPUTED_TYPES.has(target.type);
+	}));
+}, {
+	message: "a `flag` named by `completionField` may only reference STORED fields in its `where` — completion is evaluated against the raw record (before deriveAll), where computed values (derived/rollup/toggle/flag/embed/backlinks) are absent",
+	path: ["completionField"]
+}).refine((schema) => schema.spawn === void 0 || schema.spawn.when !== void 0 || schema.fields[schema.completionField ?? ""]?.type !== "flag", {
+	message: "a schema whose `completionField` names a `flag` field must declare an explicit `spawn.when` (the spawn-inert check cannot statically evaluate a flag's `where`)",
+	path: ["spawn"]
 }).refine((schema) => Object.values(schema.fields).every((field) => {
 	if (field.type !== "embed" || field.idField === void 0) return true;
 	const target = schema.fields[field.idField];
@@ -2061,6 +2189,46 @@ var CollectionSchemaZ = zod.z.object({
 	message: "schema `views` must have unique `id`s",
 	path: ["views"]
 });
+var PROTOTYPE_KEYS = [
+	"__proto__",
+	"constructor",
+	"prototype"
+];
+/** The first own prototype-sensitive key of `value`, or null. */
+function ownPrototypeKey(value) {
+	if (value === null || typeof value !== "object") return null;
+	for (const key of PROTOTYPE_KEYS) if (Object.hasOwn(value, key)) return key;
+	return null;
+}
+/** Dotted path of the first prototype-sensitive field name in the raw
+*  schema input — top-level `fields`, each table field's `of`, and each
+*  action's `params` (the three records that DEFINE names) — or null. */
+function prototypeFieldKeyPath(input) {
+	if (input === null || typeof input !== "object") return null;
+	const schema = input;
+	const bad = ownPrototypeKey(schema.fields);
+	if (bad !== null) return `fields.${bad}`;
+	for (const [key, spec] of Object.entries(schema.fields ?? {})) {
+		const badSub = ownPrototypeKey(spec?.of);
+		if (badSub !== null) return `fields.${key}.of.${badSub}`;
+	}
+	for (const [listName, list] of [["actions", schema.actions], ["collectionActions", schema.collectionActions]]) for (const action of Array.isArray(list) ? list : []) {
+		const badParam = ownPrototypeKey(action?.params);
+		if (badParam !== null) return `${listName}.params.${badParam}`;
+	}
+	return null;
+}
+var CollectionSchemaZ = zod.z.preprocess((input, ctx) => {
+	const bad = prototypeFieldKeyPath(input);
+	if (bad !== null) {
+		ctx.addIssue({
+			code: "custom",
+			message: `'${bad}': field names must not be prototype-sensitive keys (\`__proto__\`, \`constructor\`, \`prototype\`)`
+		});
+		return zod.z.NEVER;
+	}
+	return input;
+}, BareCollectionSchemaZ);
 //#endregion
 //#region src/collection/server/discovery.ts
 function applyFeedSchemaDefaults(parsed, slug) {
@@ -2621,17 +2789,15 @@ function successorId(sourceId, next) {
 }
 /** True iff `item` satisfies the spawn predicate. With an explicit
 *  `when`, matches `String(item[when.field]) ∈ when.in`. Without one,
-*  defaults to the completion-done condition. Self-contained (no import
-*  from notifications.ts) to keep the module graph acyclic. */
+*  defaults to the completion-done condition — the shared, flag-aware
+*  `itemIsDone` (core/completion; downhill import, so the module graph
+*  stays acyclic). */
 function matchesWhen(when, schema, item) {
 	if (when) {
 		const raw = item[when.field];
 		return raw !== void 0 && raw !== null && when.in.includes(String(raw));
 	}
-	const { completionField, completionDoneValues } = schema;
-	if (!completionField || !completionDoneValues) return false;
-	const raw = item[completionField];
-	return raw !== void 0 && raw !== null && completionDoneValues.includes(String(raw));
+	return require_promptSafety.itemIsDone(schema, item);
 }
 /** Resolve the literal `every` that applies to `sourceItem`. Literal-arm
 *  `spawn.every` passes through unchanged. Field-driven `spawn.every` reads
@@ -3176,17 +3342,27 @@ async function putOneItem(collection, record, mode, deps) {
 	if (result.kind === "conflict") return reject(itemId, `'${itemId}' already exists — mode "create" refuses overwrite; use "upsert" to update it`);
 	return reject(itemId, "write refused: the collection's data dir escapes the workspace");
 }
-/** Aggregation over a dataSource collection's WHOLE file via the
-*  structured query DSL (`core/queryZ.ts`) — the paved road for counts /
-*  sums / group-bys that `getItems` (row-capped, unaggregated) can't
-*  answer honestly. File-backed collections have no query engine yet:
-*  refuse with a pointer instead of silently emulating. */
+/** Aggregation over a collection via the structured query DSL
+*  (`core/queryZ.ts`) — the paved road for counts / sums / group-bys
+*  that a row listing can't answer honestly. Two engines behind one
+*  shape: a dataSource collection queries its CSV natively through the
+*  store (`store.query`, uncapped whole-file scan); a file-backed
+*  collection aggregates its ENRICHED records (computed fields —
+*  `derived` / `rollup` / `toggle` — are real columns) through the same
+*  compiled SQL over a temp JSONL (`runQueryOverRows`). */
 async function handleQueryItems(collection, queryArg, deps) {
-	const store = storeFor(collection, { workspaceRoot: deps.workspaceRoot });
-	if (!store.query) return `manageCollection: '${collection.slug}' is file-backed — queryItems currently supports only dataSource (CSV) collections; use getItems (with \`fields\`) instead.`;
 	const parsed = CollectionQueryZ.safeParse(queryArg);
 	if (!parsed.success) return `manageCollection: \`query\` rejected — fix and retry:\n${parsed.error.issues.slice(0, 20).map((issue) => `- ${issue.path.map(String).join(".") || "(root)"}: ${require_promptSafety.defangForPrompt(issue.message)}`).join("\n")}`;
-	const rows = await store.query(parsed.data);
+	const store = storeFor(collection, { workspaceRoot: deps.workspaceRoot });
+	if (store.query) {
+		const rows = await store.query(parsed.data);
+		return JSON.stringify({
+			collection: collection.slug,
+			count: rows.length,
+			rows
+		});
+	}
+	const rows = await runQueryOverRows(await enrichItems(collection, await store.list(), deps), parsed.data);
 	return JSON.stringify({
 		collection: collection.slug,
 		count: rows.length,
@@ -3316,7 +3492,7 @@ async function handlePutSchema(slug, schemaArg, deps) {
 		written: true
 	});
 }
-var MANAGE_COLLECTION_PROMPT = "Use `manageCollection` instead of raw Read/Write/Edit when working with a collection's records OR its schema (raw file I/O stays available as the escape hatch). Before authoring or changing a collection's `schema.json`, call `schemaDocs` to load the field/DSL reference, then read with `getSchema` and write with `putSchema` — `putSchema` validates the whole schema before writing and returns actionable errors instead of silently failing discovery's validation. `getItems` is the only way to see computed values — `derived` fields (e.g. a portfolio's value), `toggle` projections, and `embed` records are host-computed and never present in the stored JSON files. On large collections pass `ids` and/or `fields` to keep the result small. For a question that spans collections (\"which clients have unpaid invoices?\"), start with `getOntology`: it lists every collection with its primaryKey, record count, and outbound `ref`/`embed` relations, so you know which collections to join before reading any records. `putItems` validates every row against the schema before writing (required fields, enum values, primaryKey = record id) and returns `{ written, rejected }`; fix each rejected row using its `problem` text and retry just those rows. Never include computed fields in a row you write. To update a few fields of an existing record, use `mode: \"merge\"` with a partial row ({ id, <changed fields> }) — the default upsert replaces the WHOLE record, so a partial upsert would silently erase every optional field it omits. On a dataSource (CSV) collection, answer aggregation questions (counts, sums, averages, group-bys) with `queryItems` — it scans the WHOLE file, while getItems is row-capped, so an aggregate computed from getItems output can be silently wrong on large files.";
+var MANAGE_COLLECTION_PROMPT = "Use `manageCollection` instead of raw Read/Write/Edit when working with a collection's records OR its schema (raw file I/O stays available as the escape hatch). Before authoring or changing a collection's `schema.json`, call `schemaDocs` to load the field/DSL reference, then read with `getSchema` and write with `putSchema` — `putSchema` validates the whole schema before writing and returns actionable errors instead of silently failing discovery's validation. `getItems` is the only way to see computed values — `derived` fields (e.g. a portfolio's value), `toggle` projections, and `embed` records are host-computed and never present in the stored JSON files. On large collections pass `ids` and/or `fields` to keep the result small. For a question that spans collections (\"which clients have unpaid invoices?\"), start with `getOntology`: it lists every collection with its primaryKey, record count, and outbound `ref`/`embed` relations, so you know which collections to join before reading any records. `putItems` validates every row against the schema before writing (required fields, enum values, primaryKey = record id) and returns `{ written, rejected }`; fix each rejected row using its `problem` text and retry just those rows. Never include computed fields in a row you write. To update a few fields of an existing record, use `mode: \"merge\"` with a partial row ({ id, <changed fields> }) — the default upsert replaces the WHOLE record, so a partial upsert would silently erase every optional field it omits. Answer aggregation questions (counts, sums, averages, group-bys) with `queryItems` on ANY collection — on a dataSource (CSV) collection it scans the whole file (getItems is row-capped, so aggregates computed from its output can be silently wrong on large files); on a file-backed collection it aggregates the enriched records, so computed fields (derived/rollup/toggle) are queryable columns.";
 /** Validate getItems' optional `ids`/`fields` args, then delegate. */
 async function dispatchGetItems(collection, args, deps) {
 	const ids = optionalStringArray(args.ids, "ids");
@@ -3399,7 +3575,7 @@ var MANAGE_COLLECTION_DEFINITION = {
 			},
 			query: {
 				type: "object",
-				description: "queryItems (dataSource/CSV collections only): a structured aggregation query over the WHOLE file — `{ groupBy?: [\"col\"], aggregates?: { alias: { op: \"count\"|\"sum\"|\"avg\"|\"min\"|\"max\", column? } }, where?: [{ field, op, value }], orderBy?: [{ field, dir? }], limit? }`. At least one of groupBy/aggregates. Runs uncapped over the full file (unlike getItems), so use it for counts / sums / group-bys on large CSVs."
+				description: "queryItems: a structured aggregation query — `{ groupBy?: [\"col\"], aggregates?: { alias: { op: \"count\"|\"sum\"|\"avg\"|\"min\"|\"max\", column? } }, where?: [{ field, op, value }], orderBy?: [{ field, dir? }], limit? }`. At least one of groupBy/aggregates. On a dataSource (CSV) collection it scans the WHOLE file uncapped (unlike getItems); on a file-backed collection it aggregates the ENRICHED records, so computed fields (derived/rollup/toggle) are queryable columns. Use it for counts / sums / averages / group-bys instead of arithmetic over getItems output."
 			}
 		},
 		required: ["action"]
@@ -3522,6 +3698,12 @@ Object.defineProperty(exports, "compileCsvQuery", {
 		return compileCsvQuery;
 	}
 });
+Object.defineProperty(exports, "compileJsonlQuery", {
+	enumerable: true,
+	get: function() {
+		return compileJsonlQuery;
+	}
+});
 Object.defineProperty(exports, "compileRecordZ", {
 	enumerable: true,
 	get: function() {
@@ -3786,6 +3968,12 @@ Object.defineProperty(exports, "resolveTemplatePath", {
 		return resolveTemplatePath;
 	}
 });
+Object.defineProperty(exports, "runQueryOverRows", {
+	enumerable: true,
+	get: function() {
+		return runQueryOverRows;
+	}
+});
 Object.defineProperty(exports, "safeRecordId", {
 	enumerable: true,
 	get: function() {
@@ -3859,4 +4047,4 @@ Object.defineProperty(exports, "writeItem", {
 	}
 });
 
-//# sourceMappingURL=server-Q7ld-FlZ.cjs.map
+//# sourceMappingURL=server-CkysfLh4.cjs.map