@mulmoclaude/core 0.14.0 → 0.15.0

package/dist/{server-Cd5WdM8a.cjs → server-bsNrf2yW.cjs}

@@ -1,5 +1,5 @@
 const require_rolldown_runtime = require("./rolldown-runtime-D6vf50IK.cjs");
-const require_calendarGrid = require("./calendarGrid-C1rfCXJ3.cjs");
+const require_calendarGrid = require("./calendarGrid-gN4sei7s.cjs");
 const require_collection_paths = require("./collection/paths.cjs");
 let node_path = require("node:path");
 node_path = require_rolldown_runtime.__toESM(node_path, 1);
@@ -239,7 +239,9 @@ async function writeFileAtomic(filePath, content) {
 *  inside an otherwise-contained data dir — without this, a record
 *  file could symlink to /etc/passwd and the detail endpoint would
 *  happily serve it. Returns false on ENOENT and on any other lstat
-*  failure so the caller's "missing" branch covers those cases too. */
+*  failure so the caller's "missing" branch covers those cases too.
+*  Exported so `ontology.ts`'s record COUNT classifies entries with the
+*  SAME lstat logic — the two must agree on what a record file is. */
 async function isRegularFile(filePath) {
 	try {
 		return (await (0, node_fs_promises.lstat)(filePath)).isFile();
@@ -635,13 +637,6 @@ ${templateText}`;
 }
 //#endregion
 //#region src/collection/core/recordZ.ts
-/** derived/embed/toggle are host-computed or projected — never written to
-*  the record JSON, so required / value checks must not apply to them. */
-var COMPUTED_TYPES = /* @__PURE__ */ new Set([
-	"derived",
-	"embed",
-	"toggle"
-]);
 /** The emptiness rule shared by `required` and the "only check present
 *  values" gate. NOT a truthiness check — `0` and `false` are filled. */
 var isEmptyValue = (value) => value === void 0 || value === null || value === "";
@@ -720,7 +715,7 @@ var compiled = /* @__PURE__ */ new WeakMap();
 function compileRecordZ(schema, tier) {
 	const cached = compiled.get(schema)?.[tier];
 	if (cached) return cached;
-	const stored = Object.entries(schema.fields).filter(([, spec]) => !COMPUTED_TYPES.has(spec.type));
+	const stored = Object.entries(schema.fields).filter(([, spec]) => !require_calendarGrid.COMPUTED_TYPES.has(spec.type));
 	const validator = zod.z.looseObject({}).superRefine((record, ctx) => {
 		for (const [key, spec] of stored) {
 			const problem = recordFieldProblem(key, spec, record[key], tier);
@@ -998,6 +993,24 @@ var EmbedFieldZ = zod.z.object({
 	message: "fields with type 'embed' must declare a `to` (valid collection slug) and exactly one of `id` (a fixed record's primary key) or `idField` (a sibling field naming the per-record target)",
 	path: ["id"]
 });
+/** Display-only REVERSE refs (plan step ② of plans/collection-ontology.md):
+*  a read-only sub-table of the records in collection `from` whose `via`
+*  ref field stores THIS record's primary key. Stores nothing (joins
+*  `COMPUTED_TYPES`); resolution is shared server/client via
+*  `core/backlinks.ts`. `display` names the `from` columns to show;
+*  `filter` (the standard `when` shape, matched against each SOURCE
+*  record) narrows the rows. Validation is shape-only, like `embed`:
+*  `from` must be a safe slug, but whether it exists — and whether `via` /
+*  `display` name real fields there — resolves fail-soft at render
+*  (empty sub-table). Do NOT add cross-schema existence checks here. */
+var BacklinksFieldZ = zod.z.object({
+	type: zod.z.literal("backlinks"),
+	...fieldBase,
+	from: zod.z.string().min(1),
+	via: zod.z.string().trim().min(1),
+	display: zod.z.array(zod.z.string().trim().min(1)).min(1),
+	filter: WhenZ.optional()
+}).refine((spec) => require_calendarGrid.isSafeSlug(spec.from), slugMessage("from"));
 /** A checkbox that is a pure PROJECTION of an `enum` field — it stores
 *  nothing of its own. Checked when the enum named by `field` equals
 *  `onValue`; toggling writes `onValue` / `offValue` back to that enum
@@ -1020,6 +1033,7 @@ var FieldSpecZ = zod.z.discriminatedUnion("type", [
 	TableFieldZ,
 	DerivedFieldZ,
 	EmbedFieldZ,
+	BacklinksFieldZ,
 	ToggleFieldZ
 ]);
 /** A schema-declared record action, rendered as a button in the read-only
@@ -1550,6 +1564,72 @@ function toDetail(collection) {
 	};
 }
 //#endregion
+//#region src/collection/server/ontology.ts
+/** Extract the relations a schema declares, in field declaration order:
+*  top-level `ref` / `embed` / `backlinks` fields plus `ref` sub-fields
+*  inside `table` columns. Pure — exported so the phase-2 graph panel
+*  can reuse it on already-loaded schemas. */
+function schemaRelations(schema) {
+	const relations = [];
+	for (const [key, spec] of Object.entries(schema.fields)) {
+		if (spec.type === "ref" || spec.type === "embed") relations.push({
+			field: key,
+			kind: spec.type,
+			to: spec.to
+		});
+		if (spec.type === "backlinks") relations.push({
+			field: key,
+			kind: "backlinks",
+			to: spec.from
+		});
+		if (spec.type !== "table") continue;
+		for (const [subKey, subSpec] of Object.entries(spec.of)) if (subSpec.type === "ref") relations.push({
+			field: `${key}.${subKey}`,
+			kind: "ref",
+			to: subSpec.to
+		});
+	}
+	return relations;
+}
+/** Count the record files in a collection's data dir — the same
+*  `<id>.json` entries `listItems` considers, WITHOUT parsing them (the
+*  ontology is a summary; a malformed record is still a record). Each
+*  candidate is classified by the SHARED `isRegularFile` lstat helper —
+*  the exact file-disclosure defense `listItems` applies — so a
+*  symlinked record never counts and the count can't diverge from the
+*  readable set on any filesystem (Codex review on PR #2099, twice).
+*  Fail-soft: a missing dir or a dataDir escaping the workspace via
+*  symlink counts 0. */
+async function countRecordFiles(dataDir, workspaceRoot) {
+	if (!isContainedInRoot(dataDir, workspaceRoot)) return 0;
+	try {
+		const names = (await (0, node_fs_promises.readdir)(dataDir)).filter((name) => name.endsWith(".json") && !name.startsWith("."));
+		return (await Promise.all(names.map((name) => isRegularFile(node_path.default.join(dataDir, name))))).filter(Boolean).length;
+	} catch {
+		return 0;
+	}
+}
+async function toOntologyEntry(collection, workspaceRoot) {
+	const { schema } = collection;
+	return {
+		slug: collection.slug,
+		title: schema.title,
+		icon: schema.icon,
+		primaryKey: schema.primaryKey,
+		displayField: schema.displayField ?? schema.primaryKey,
+		recordCount: await countRecordFiles(collection.dataDir, workspaceRoot),
+		relations: schemaRelations(schema)
+	};
+}
+/** Build the workspace ontology: every discovered collection (slug-sorted,
+*  discovery's order), each with its outbound relations and a
+*  readdir-cheap record count — fine to call on demand. */
+async function buildWorkspaceOntology(opts = {}) {
+	const workspaceRoot = opts.workspaceRoot ?? getWorkspaceRoot();
+	const collections = await discoverCollections(opts);
+	return Promise.all(collections.map((collection) => toOntologyEntry(collection, workspaceRoot)));
+}
+//#endregion
 //#region src/collection/server/derive.ts
 /** Slugs of every collection referenced by a `ref` field — top-level
 *  and one level into `table` sub-fields (nested tables are
@@ -1572,6 +1652,13 @@ function uniqueEmbedTargets(schema) {
 	for (const field of Object.values(schema.fields)) if (field.type === "embed" && typeof field.to === "string" && field.to.length > 0) targets.add(field.to);
 	return [...targets];
 }
+/** Slugs of every SOURCE collection a `backlinks` field reverses over —
+*  loaded exactly like ref/embed targets (whole collection, once). */
+function uniqueBacklinkSources(schema) {
+	const sources = /* @__PURE__ */ new Set();
+	for (const field of Object.values(schema.fields)) if (field.type === "backlinks" && field.from.length > 0) sources.add(field.from);
+	return [...sources];
+}
 async function loadTarget(slug, opts) {
 	const target = await loadCollection(slug, opts);
 	if (!target) return null;
@@ -1586,11 +1673,16 @@ async function loadTarget(slug, opts) {
 		byId
 	};
 }
-/** Load every ref/embed target collection once. Unknown / unloadable
-*  targets are simply absent — downstream derefs resolve to null, the
-*  same fail-soft the UI renders as an em-dash. */
+/** Load every ref/embed target and backlink source collection once.
+*  Unknown / unloadable targets are simply absent — downstream derefs
+*  resolve to null (em-dash) and backlinks to an empty row set, the
+*  same fail-soft the UI renders. */
 async function loadLinkedTargets(schema, opts) {
-	const slugs = [.../* @__PURE__ */ new Set([...uniqueRefTargets(schema), ...uniqueEmbedTargets(schema)])];
+	const slugs = [.../* @__PURE__ */ new Set([
+		...uniqueRefTargets(schema),
+		...uniqueEmbedTargets(schema),
+		...uniqueBacklinkSources(schema)
+	])];
 	const loaded = {};
 	for (const slug of slugs) {
 		const target = await loadTarget(slug, opts);
@@ -1601,9 +1693,21 @@ async function loadLinkedTargets(schema, opts) {
 function toRefRecords(linked) {
 	return Object.fromEntries(Object.entries(linked).map(([slug, target]) => [slug, target.byId]));
 }
+/** The matching source rows for one `backlinks` field, projected to the
+*  source primaryKey + `display` columns — so getItems on a
+*  heavily-referenced record stays a summary, not a dump of the source
+*  collection. Missing source ⇒ [] (fail-soft). The rows come from the
+*  DERIVED source records (`byId`), so `display`/`filter` on a derived
+*  source column (an invoice `total`) works. */
+function projectBacklinks(field, schema, enriched, linked) {
+	const source = linked[field.from];
+	if (!source) return [];
+	return require_calendarGrid.backlinkRows(field, String(enriched[schema.primaryKey] ?? ""), Object.values(source.byId)).map((row) => require_calendarGrid.projectBacklinkRow(row, field.display, source.schema.primaryKey));
+}
 /** Project the computed (never-stored) field kinds onto one derived
 *  record: `toggle` → boolean off its enum, `embed` → the target record
-*  (fixed `id` or per-record `idField`), or null when missing. */
+*  (fixed `id` or per-record `idField`), or null when missing,
+*  `backlinks` → the matching source rows (see `projectBacklinks`). */
 function projectComputed(schema, enriched, linked) {
 	for (const [key, field] of Object.entries(schema.fields)) {
 		if (field.type === "toggle" && field.field) enriched[key] = String(enriched[field.field] ?? "") === field.onValue;
@@ -1611,6 +1715,7 @@ function projectComputed(schema, enriched, linked) {
 			const targetId = require_calendarGrid.embedTargetId(field, enriched);
 			enriched[key] = targetId && linked[field.to]?.byId[targetId] || null;
 		}
+		if (field.type === "backlinks") enriched[key] = projectBacklinks(field, schema, enriched, linked);
 	}
 	return enriched;
 }
@@ -2147,12 +2252,6 @@ async function deleteCustomView(collection, viewId, opts = {}) {
 	};
 }
 //#endregion
-Object.defineProperty(exports, "COMPUTED_TYPES", {
-	enumerable: true,
-	get: function() {
-		return COMPUTED_TYPES;
-	}
-});
 Object.defineProperty(exports, "CollectionSchemaZ", {
 	enumerable: true,
 	get: function() {
@@ -2195,6 +2294,12 @@ Object.defineProperty(exports, "buildCollectionActionSeedPrompt", {
 		return buildCollectionActionSeedPrompt;
 	}
 });
+Object.defineProperty(exports, "buildWorkspaceOntology", {
+	enumerable: true,
+	get: function() {
+		return buildWorkspaceOntology;
+	}
+});
 Object.defineProperty(exports, "collectionsRegistriesConfigPath", {
 	enumerable: true,
 	get: function() {
@@ -2303,6 +2408,12 @@ Object.defineProperty(exports, "isContainedInWorkspace", {
 		return isContainedInWorkspace;
 	}
 });
+Object.defineProperty(exports, "isRegularFile", {
+	enumerable: true,
+	get: function() {
+		return isRegularFile;
+	}
+});
 Object.defineProperty(exports, "isTriggerDue", {
 	enumerable: true,
 	get: function() {
@@ -2423,6 +2534,12 @@ Object.defineProperty(exports, "safeSlugName", {
 		return safeSlugName;
 	}
 });
+Object.defineProperty(exports, "schemaRelations", {
+	enumerable: true,
+	get: function() {
+		return schemaRelations;
+	}
+});
 Object.defineProperty(exports, "setCollectionChangePublisher", {
 	enumerable: true,
 	get: function() {
@@ -2472,4 +2589,4 @@ Object.defineProperty(exports, "writeItem", {
 	}
 });
 
-//# sourceMappingURL=server-Cd5WdM8a.cjs.map
+//# sourceMappingURL=server-bsNrf2yW.cjs.map