@mulmoclaude/core 0.14.0 → 0.15.0

package/dist/{server-Cc6XcyOA.js → server-BNTR7ySK.js}

@@ -1,4 +1,4 @@
-import { A as isFieldDrivenEvery, C as SAFE_SLUG_PATTERN, D as FEED_SCHEDULES, E as AGENT_INGEST_KIND, O as INGEST_KINDS, S as SAFE_RECORD_ID_PATTERN, T as isSafeSlug, b as selectDynamicRecord, h as deriveAll, k as embedTargetId, l as parseIsoDate, u as parseIsoDateTime, v as firstDateField, w as isSafeRecordId, y as resolveIcon } from "./calendarGrid-kO6rGfm0.js";
+import { A as isSafeSlug, C as projectBacklinkRow, D as SAFE_RECORD_ID_PATTERN, F as embedTargetId, I as isFieldDrivenEvery, M as COMPUTED_TYPES, N as FEED_SCHEDULES, O as SAFE_SLUG_PATTERN, P as INGEST_KINDS, S as backlinkRows, b as selectDynamicRecord, h as deriveAll, j as AGENT_INGEST_KIND, k as isSafeRecordId, l as parseIsoDate, u as parseIsoDateTime, v as firstDateField, y as resolveIcon } from "./calendarGrid-CaR-q36Y.js";
 import { isSafeActionTemplatePath, isSafeCustomViewI18nPath, isSafeCustomViewPath } from "./collection/paths.js";
 import path from "node:path";
 import { promises, realpathSync } from "node:fs";
@@ -237,7 +237,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 lstat(filePath)).isFile();
@@ -633,13 +635,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 === "";
@@ -996,6 +991,24 @@ var EmbedFieldZ = 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 = z.object({
+	type: z.literal("backlinks"),
+	...fieldBase,
+	from: z.string().min(1),
+	via: z.string().trim().min(1),
+	display: z.array(z.string().trim().min(1)).min(1),
+	filter: WhenZ.optional()
+}).refine((spec) => 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
@@ -1018,6 +1031,7 @@ var FieldSpecZ = z.discriminatedUnion("type", [
 	TableFieldZ,
 	DerivedFieldZ,
 	EmbedFieldZ,
+	BacklinksFieldZ,
 	ToggleFieldZ
 ]);
 /** A schema-declared record action, rendered as a button in the read-only
@@ -1548,6 +1562,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 readdir(dataDir)).filter((name) => name.endsWith(".json") && !name.startsWith("."));
+		return (await Promise.all(names.map((name) => isRegularFile(path.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
@@ -1570,6 +1650,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;
@@ -1584,11 +1671,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);
@@ -1599,9 +1691,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 backlinkRows(field, String(enriched[schema.primaryKey] ?? ""), Object.values(source.byId)).map((row) => 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;
@@ -1609,6 +1713,7 @@ function projectComputed(schema, enriched, linked) {
 			const targetId = 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;
 }
@@ -2145,6 +2250,6 @@ async function deleteCustomView(collection, viewId, opts = {}) {
 	};
 }
 //#endregion
-export { publishCollectionChange as $, deleteItem as A, writeFileAtomic as B, validateCollectionRecords as C, recordFieldProblem as D, compileRecordZ as E, readCustomViewI18n as F, resolveDataDir as G, isContainedInRoot as H, readItem as I, safeSlugName as J, resolveTemplatePath as K, readSkillTemplate as L, listItems as M, promptPathsFor as N, buildActionSeedPrompt as O, readCustomViewHtml as P, log as Q, resolveCreateItemId as R, CollectionSchemaZ as S, COMPUTED_TYPES as T, isContainedInWorkspace as U, SCHEMA_FILE as V, itemFilePath as W, configureCollectionHost as X, collectionsRegistriesConfigPath as Y, getWorkspaceRoot as Z, acceptParsedSchema as _, computeSuccessor as a, toDetail as b, isTriggerDue as c, resolveEvery as d, setCollectionChangePublisher as et, successorId as f, enrichItems as g, computeCollectionIcon as h, advanceTriggerDate as i, generateItemId as j, buildCollectionActionSeedPrompt as k, maybeSpawnSuccessor as l, errorMessage as m, deleteCollection as n, daysInMonth as o, ONE_SECOND_MS as p, safeRecordId as q, deleteCollectionRefusalMessage as r, formatCivil as s, deleteCustomView as t, parseCivil as u, discoverCollections as v, validateRecordObject as w, toSummary as x, loadCollection as y, writeItem as z };
+export { getWorkspaceRoot as $, buildCollectionActionSeedPrompt as A, resolveCreateItemId as B, toSummary as C, compileRecordZ as D, validateRecordObject as E, promptPathsFor as F, isContainedInWorkspace as G, writeFileAtomic as H, readCustomViewHtml as I, resolveTemplatePath as J, itemFilePath as K, readCustomViewI18n as L, generateItemId as M, isRegularFile as N, recordFieldProblem as O, listItems as P, configureCollectionHost as Q, readItem as R, toDetail as S, validateCollectionRecords as T, SCHEMA_FILE as U, writeItem as V, isContainedInRoot as W, safeSlugName as X, safeRecordId as Y, collectionsRegistriesConfigPath as Z, buildWorkspaceOntology as _, computeSuccessor as a, discoverCollections as b, isTriggerDue as c, resolveEvery as d, log as et, successorId as f, enrichItems as g, computeCollectionIcon as h, advanceTriggerDate as i, deleteItem as j, buildActionSeedPrompt as k, maybeSpawnSuccessor as l, errorMessage as m, deleteCollection as n, setCollectionChangePublisher as nt, daysInMonth as o, ONE_SECOND_MS as p, resolveDataDir as q, deleteCollectionRefusalMessage as r, formatCivil as s, deleteCustomView as t, publishCollectionChange as tt, parseCivil as u, schemaRelations as v, CollectionSchemaZ as w, loadCollection as x, acceptParsedSchema as y, readSkillTemplate as z };
 
-//# sourceMappingURL=server-Cc6XcyOA.js.map
+//# sourceMappingURL=server-BNTR7ySK.js.map