@mulmoclaude/core 1.12.0 → 1.14.0

package/dist/{discovery-B4CZvrXR.js → discovery-D6p4ITNR.js}

@@ -1,6 +1,7 @@
+import { a as isErrorWithCode, l as isUnknownArray, r as hasNumberProp, s as isRecord } from "./dist-D8zokgGo.js";
 import { t as writeFileAtomic } from "./atomic-DPpdrJzO.js";
-import { A as fieldTextOrNull, C as FEED_SCHEDULES, D as isReadOnlySchema, O as storageKindFor, S as COMPUTED_TYPES, g as SAFE_SLUG_PATTERN, h as SAFE_RECORD_ID_PATTERN, k as fieldText, v as isSafeRecordId, w as INGEST_KINDS, x as AGENT_INGEST_KIND, y as isSafeSlug } from "./calendarGrid-CrGxeCOG.js";
-import { t as projectRecordFields } from "./project-bU98ycsy.js";
+import { A as fieldTextOrNull, C as FEED_SCHEDULES, D as isReadOnlySchema, O as storageKindFor, S as COMPUTED_TYPES, g as SAFE_SLUG_PATTERN, h as SAFE_RECORD_ID_PATTERN, k as fieldText, v as isSafeRecordId, w as INGEST_KINDS, x as AGENT_INGEST_KIND, y as isSafeSlug } from "./calendarGrid-DivcNKkX.js";
+import { n as projectRecordFields } from "./project-B0j_Vf_Q.js";
 import { n as isSafeCustomViewI18nPath, r as isSafeCustomViewPath, t as isSafeActionTemplatePath } from "./templatePath-k_WNbL_Q.js";
 import { realpathSync, watch } from "node:fs";
 import path from "node:path";
@@ -141,7 +142,7 @@ function realpathClosestAncestor(absPath) {
 	while (cursor !== path.dirname(cursor)) try {
 		return realpathSync(cursor);
 	} catch (err) {
-		if (err.code === "ENOENT") {
+		if (isErrorWithCode(err) && err.code === "ENOENT") {
 			cursor = path.dirname(cursor);
 			continue;
 		}
@@ -245,8 +246,7 @@ async function isRegularFile(filePath) {
 *  null when it isn't a JSON object (array / scalar / null). */
 function parseRecordJson(raw) {
 	const parsed = JSON.parse(raw);
-	if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
-	return null;
+	return isRecord(parsed) ? parsed : null;
 }
 async function tryReadRecord(filePath) {
 	if (!await isRegularFile(filePath)) return null;
@@ -271,7 +271,7 @@ async function listItems(dataDir, opts = {}) {
 	try {
 		entries = await readdir(dataDir);
 	} catch (err) {
-		if (err.code === "ENOENT") return [];
+		if (isErrorWithCode(err) && err.code === "ENOENT") return [];
 		throw err;
 	}
 	const results = [];
@@ -301,7 +301,7 @@ async function readItem(dataDir, itemId, opts = {}) {
 	try {
 		return parseRecordJson(await readFile(filePath, "utf-8"));
 	} catch (err) {
-		if (err.code === "ENOENT") return null;
+		if (isErrorWithCode(err) && err.code === "ENOENT") return null;
 		throw err;
 	}
 }
@@ -371,7 +371,7 @@ async function writeItem(dataDir, itemId, item, opts = {}) {
 		try {
 			handle = await open(filePath, "wx");
 		} catch (err) {
-			if (err.code === "EEXIST") return {
+			if (isErrorWithCode(err) && err.code === "EEXIST") return {
 				kind: "conflict",
 				itemId: safeId
 			};
@@ -417,7 +417,7 @@ async function deleteItem(dataDir, itemId, opts = {}) {
 			itemId: safeId
 		};
 	} catch (err) {
-		if (err.code === "ENOENT") return {
+		if (isErrorWithCode(err) && err.code === "ENOENT") return {
 			kind: "not-found",
 			itemId: safeId
 		};
@@ -595,7 +595,7 @@ function whereFragment(cond) {
 	}
 	if (cond.op === "contains") return {
 		sql: `contains(${asText}, ?)`,
-		params: [String(cond.value)]
+		params: [String(scalarValue(cond))]
 	};
 	const operator = {
 		eq: "=",
@@ -607,9 +607,16 @@ function whereFragment(cond) {
 	}[cond.op];
 	return {
 		sql: `${typeof cond.value === "string" && (cond.op === "eq" || cond.op === "ne") ? asText : column} ${operator} ?`,
-		params: [cond.value]
+		params: [scalarValue(cond)]
 	};
 }
+/** `CollectionQueryZ` refines "`in` ⇔ array value", so an array reaching a
+*  scalar op means the query was compiled without being validated first —
+*  binding it would send an array to a single `?`. */
+function scalarValue(cond) {
+	if (Array.isArray(cond.value)) throw new Error(`where condition on '${cond.field}' uses op '${cond.op}', which requires a scalar value, not an array`);
+	return cond.value;
+}
 /** 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.
@@ -831,7 +838,7 @@ async function safeCsvStat(absPath, workspaceRoot) {
 	try {
 		info = await lstat(absPath);
 	} catch (err) {
-		if (err.code === "ENOENT") return null;
+		if (isErrorWithCode(err) && err.code === "ENOENT") return null;
 		throw err;
 	}
 	if (!info.isFile()) {
@@ -1045,7 +1052,7 @@ function projectItemFields(items, fields, primaryKey) {
 *  tests. `limit: 0` is a valid "count only" page. */
 function pageFromFullRead(items, opts, primaryKey, truncated) {
 	const offset = Math.max(0, opts.offset ?? 0);
-	const end = opts.limit === void 0 ? void 0 : offset + Math.max(0, opts.limit);
+	const end = opts.limit === void 0 ? items.length : offset + Math.max(0, opts.limit);
 	return {
 		items: projectItemFields(items.slice(offset, end), opts.fields, primaryKey),
 		total: items.length,
@@ -1054,14 +1061,23 @@ function pageFromFullRead(items, opts, primaryKey, truncated) {
 }
 //#endregion
 //#region src/collection/server/sqliteStore.ts
+/** A constructor's parameter and return types are not observable at runtime,
+*  so the check stops at "DatabaseSync is constructible" — the only member of
+*  the module this store ever touches. */
+function isSqliteModule(mod) {
+	return isRecord(mod) && typeof mod.DatabaseSync === "function";
+}
 var sqliteModule = null;
+/** Drops the memo first so a later call can retry (e.g. tests stubbing the
+*  runtime), then reports why the backend is unusable. */
+function sqliteUnavailable(reason) {
+	sqliteModule = null;
+	throw new BackendUnavailableError(`sqlite storage needs the node:sqlite module (Node.js >= 22.5) — this runtime cannot load it: ${reason}`);
+}
 /** Lazy-load node:sqlite once. A runtime without it (Node < 22.5) throws a
 *  clearly-worded error the caller surfaces — never a bare MODULE_NOT_FOUND. */
 function loadSqlite() {
-	sqliteModule ??= import("node:sqlite").then((mod) => mod, (err) => {
-		sqliteModule = null;
-		throw new BackendUnavailableError(`sqlite storage needs the node:sqlite module (Node.js >= 22.5) — this runtime cannot load it: ${String(err)}`);
-	});
+	sqliteModule ??= import("node:sqlite").then((mod) => isSqliteModule(mod) ? mod : sqliteUnavailable("the module exposes no DatabaseSync constructor"), (err) => sqliteUnavailable(String(err)));
 	return sqliteModule;
 }
 /** The db file's on-disk state. A symlink or non-regular file is refused
@@ -1073,7 +1089,7 @@ async function dbFileState(absPath) {
 	try {
 		return (await lstat(absPath)).isFile() ? "file" : "refused";
 	} catch (err) {
-		if (err.code === "ENOENT") return "missing";
+		if (isErrorWithCode(err) && err.code === "ENOENT") return "missing";
 		throw err;
 	}
 }
@@ -1125,27 +1141,39 @@ async function withDb(absPath, workspaceRoot, mode, onUnavailable, operation) {
 		handle.database.close();
 	}
 }
+var SQLITE_CONSTRAINT_PRIMARYKEY = 1555;
+var SQLITE_CONSTRAINT_UNIQUE = 2067;
 /** node:sqlite throws ERR_SQLITE_ERROR with the SQLite extended result
-*  code on `errcode`. Our INSERT's duplicate-id failure is
-*  SQLITE_CONSTRAINT_PRIMARYKEY (1555); SQLITE_CONSTRAINT_UNIQUE (2067)
-*  covers a plain UNIQUE index. Checked structurally (message text kept
-*  only as a fallback for runtimes that don't expose `errcode`). */
+*  code on `errcode`. Checked structurally (message text kept only as a
+*  fallback for runtimes that don't expose `errcode`). */
 function isUniqueConstraintError(err) {
-	const { errcode } = err;
-	if (errcode !== void 0) return errcode === 1555 || errcode === 2067;
+	if (hasNumberProp(err, "errcode")) return err.errcode === SQLITE_CONSTRAINT_PRIMARYKEY || err.errcode === SQLITE_CONSTRAINT_UNIQUE;
 	return String(err).includes("UNIQUE constraint");
 }
 function parseRow(raw) {
 	if (typeof raw !== "string") return null;
 	try {
 		const parsed = JSON.parse(raw);
-		return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+		return isRecord(parsed) ? parsed : null;
 	} catch {
 		return null;
 	}
 }
+/** One column of a result row. node:sqlite types rows as `unknown`, so a
+*  value that is not a row object yields no column at all. */
+function readColumn(row, column) {
+	return isRecord(row) ? row[column] : void 0;
+}
 function rowsToItems(rows) {
-	return rows.map((row) => parseRow(row.record)).filter((item) => item !== null);
+	return rows.map((row) => parseRow(readColumn(row, "record"))).filter((item) => item !== null);
+}
+/** node:sqlite hands back an integer column as `number`, or as `bigint` once
+*  it leaves the safe-integer range — COUNT(*) can be either. */
+function countRecords(database) {
+	const count = readColumn(database.prepare("SELECT COUNT(*) AS n FROM records").get(), "n");
+	if (typeof count === "number") return count;
+	if (typeof count === "bigint") return Number(count);
+	throw new Error(`sqlite COUNT(*) returned no numeric row count (got ${typeof count})`);
 }
 async function sqliteList(absPath, workspaceRoot) {
 	return withDb(absPath, workspaceRoot, "read", () => [], (database) => rowsToItems(database.prepare("SELECT record FROM records ORDER BY id").all()));
@@ -1157,7 +1185,7 @@ async function sqlitePage(absPath, primaryKey, opts, workspaceRoot) {
 		truncated: false
 	};
 	return withDb(absPath, workspaceRoot, "read", () => emptyPage, (database) => {
-		const total = Number(database.prepare("SELECT COUNT(*) AS n FROM records").get().n);
+		const total = countRecords(database);
 		const offset = Math.max(0, opts.offset ?? 0);
 		const limit = opts.limit === void 0 ? -1 : Math.max(0, opts.limit);
 		return {
@@ -1171,8 +1199,7 @@ async function sqliteRead(absPath, itemId, workspaceRoot) {
 	const safeId = safeRecordId(itemId);
 	if (safeId === null) return null;
 	return withDb(absPath, workspaceRoot, "read", () => null, (database) => {
-		const row = database.prepare("SELECT record FROM records WHERE id = ?").get(safeId);
-		return row === void 0 ? null : parseRow(row.record);
+		return parseRow(readColumn(database.prepare("SELECT record FROM records WHERE id = ?").get(safeId), "record"));
 	});
 }
 async function sqliteWrite(absPath, itemId, item, opts) {
@@ -2150,7 +2177,7 @@ var SpawnZ = z.object({
 *  items natively and ignore it — so no kind-specific requirement here. */
 var DeclarativeIngestZ = z.object({
 	kind: z.enum(INGEST_KINDS),
-	url: z.string().url(),
+	url: z.url(),
 	schedule: z.enum(FEED_SCHEDULES),
 	atHour: z.number().int().min(0).max(23).optional(),
 	itemsAt: z.string().trim().min(1).optional(),
@@ -2405,23 +2432,38 @@ function ownPrototypeKey(value) {
 	for (const key of PROTOTYPE_KEYS) if (Object.hasOwn(value, key)) return key;
 	return null;
 }
+/** Own enumerable entries of an object (arrays keyed by index), none for
+*  anything else — the raw input is unvalidated, so `fields` may be junk. */
+function ownEntries(value) {
+	if (isUnknownArray(value)) return value.map((entry, index) => [String(index), entry]);
+	return isRecord(value) ? Object.entries(value) : [];
+}
+/** The name-defining sub-record a raw field spec (`of`) or action (`params`)
+*  carries, or undefined when the holder isn't an object at all. */
+function nameDefiningSubRecord(holder, key) {
+	return isRecord(holder) ? holder[key] : void 0;
+}
+/** Dotted path of the first prototype-sensitive `params` name across both
+*  action lists, or null. */
+function prototypeActionParamPath(input) {
+	for (const [listName, list] of [["actions", input.actions], ["collectionActions", input.collectionActions]]) for (const action of isUnknownArray(list) ? list : []) {
+		const badParam = ownPrototypeKey(nameDefiningSubRecord(action, "params"));
+		if (badParam !== null) return `${listName}.params.${badParam}`;
+	}
+	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 (!isRecord(input)) return null;
+	const bad = ownPrototypeKey(input.fields);
 	if (bad !== null) return `fields.${bad}`;
-	for (const [key, spec] of Object.entries(schema.fields ?? {})) {
-		const badSub = ownPrototypeKey(spec?.of);
+	for (const [key, spec] of ownEntries(input.fields)) {
+		const badSub = ownPrototypeKey(nameDefiningSubRecord(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;
+	return prototypeActionParamPath(input);
 }
 var CollectionSchemaZ = z.preprocess((input, ctx) => {
 	const bad = prototypeFieldKeyPath(input);
@@ -2437,11 +2479,10 @@ var CollectionSchemaZ = z.preprocess((input, ctx) => {
 //#endregion
 //#region src/collection/server/discovery.ts
 function applyFeedSchemaDefaults(parsed, slug) {
-	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return parsed;
-	const obj = parsed;
-	const icon = typeof obj.icon === "string" && obj.icon.trim().length > 0 ? obj.icon : "dynamic_feed";
+	if (!isRecord(parsed)) return parsed;
+	const icon = typeof parsed.icon === "string" && parsed.icon.trim().length > 0 ? parsed.icon : "dynamic_feed";
 	return {
-		...obj,
+		...parsed,
 		icon,
 		dataPath: `data/feeds/${slug}`
 	};
@@ -2544,7 +2585,7 @@ async function loadOneCollection(skillsRoot, slug, source, workspaceRoot) {
 		if (!(await stat(schemaPath)).isFile()) return null;
 		raw = await readFile(schemaPath, "utf-8");
 	} catch (err) {
-		if (err.code !== "ENOENT") log.warn("collections", "failed to read schema.json, skipping", {
+		if (!isErrorWithCode(err) || err.code !== "ENOENT") log.warn("collections", "failed to read schema.json, skipping", {
 			slug: safeName,
 			path: schemaPath,
 			error: String(err)
@@ -2598,7 +2639,7 @@ async function collectFromDir(skillsRoot, source, workspaceRoot) {
 	try {
 		entries = await readdir(skillsRoot);
 	} catch (err) {
-		if (err.code === "ENOENT") return [];
+		if (isErrorWithCode(err) && err.code === "ENOENT") return [];
 		log.warn("collections", "failed to list skills dir, returning empty", {
 			root: skillsRoot,
 			error: String(err)
@@ -2674,4 +2715,4 @@ function toDetail(collection) {
 //#endregion
 export { skillsStagingDir as $, deleteItem as A, itemFilePath as B, compileCsvQuery as C, MAX_QUERY_ROWS as D, DEFAULT_QUERY_ROWS as E, resolveCreateItemId as F, archiveDir as G, resolveTemplatePath as H, writeItem as I, getWorkspaceRoot as J, collectionsRegistriesConfigPath as K, SCHEMA_FILE as L, isRegularFile as M, listItems as N, BackendUnavailableError as O, readItem as P, setCollectionChangePublisher as Q, isContainedInRoot as R, queryCsv as S, CollectionQueryZ as T, safeRecordId as U, resolveDataDir as V, safeSlugName as W, log as X, isPresetSlug as Y, publishCollectionChange as Z, csvRowToItem as _, toDetail as a, encodeCsvRecordId as b, resolveMutateSet as c, storeFor as d, createForwardingLogger as et, checkpointSqliteDatabase as f, cacheDir as g, MAX_CSV_ROWS as h, resolvePrimaryField as i, generateItemId as j, isBackendUnavailable as k, collectionWritable as l, projectItemFields as m, discoverCollections as n, toSummary as o, pageFromFullRead as p, configureCollectionHost as q, loadCollection as r, CollectionSchemaZ as s, acceptParsedSchema as t, createHostSlot as tt, readOnlyRefusal as u, decodeCsvRecordId as v, compileJsonlQuery as w, normalizeCsvValue as x, dedupeByRecordId as y, isContainedInWorkspace as z };
 
-//# sourceMappingURL=discovery-B4CZvrXR.js.map
+//# sourceMappingURL=discovery-D6p4ITNR.js.map