@mulmoclaude/collection-plugin 0.5.2 → 0.5.6

package/dist/server.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_chunk = require("./chunk-CKQMccvm.cjs");
-const require_schema = require("./schema-LrmrgW12.cjs");
+const require_schema = require("./schema-5P5ZJPrY.cjs");
 const require_deriveAll = require("./deriveAll-BJ0Lvm1Q.cjs");
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path, 1);
@@ -10,6 +10,7 @@ let node_crypto = require("node:crypto");
 let zod = require("zod");
 //#region src/server/host.ts
 var current = null;
+var changePublisher = null;
 /** Wire the engine to a host. Call once at server startup, before any
 *  collection storage operation. Re-binding to a *different* host throws —
 *  silently redirecting later filesystem operations to another workspace
@@ -18,6 +19,22 @@ function configureCollectionHost(host) {
 	if (current !== null && current !== host) throw new Error("@mulmoclaude/collection-plugin/server: configureCollectionHost() was already called with a different host");
 	current = host;
 }
+/** Wire a publisher that broadcasts record-change events; the host bridges it
+*  to its pubsub. Kept SEPARATE from `configureCollectionHost` because the
+*  host's pubsub instance isn't ready at host-binding time (the binding is set
+*  at the top of server startup, the pubsub later). Optional: left unset, every
+*  write is silent — the default for tests and for a host that doesn't want
+*  live view updates. Pass `null` to detach (test teardown). */
+function setCollectionChangePublisher(publish) {
+	changePublisher = publish;
+}
+/** Broadcast a record-change event if a publisher is wired (no-op otherwise).
+*  Called from the write path (`writeItem`/`deleteItem`). The wired publisher is
+*  expected to be fire-and-forget (it wraps its own pubsub call in try/catch),
+*  so this stays a thin pass-through and never throws into the write. */
+function publishCollectionChange(payload) {
+	changePublisher?.(payload);
+}
 function requireHost() {
 	if (current === null) throw new Error("@mulmoclaude/collection-plugin/server: configureCollectionHost() was not called by the host");
 	return current;
@@ -394,13 +411,12 @@ async function writeItem(dataDir, itemId, item, opts = {}) {
 		} finally {
 			await handle.close();
 		}
-		return {
-			kind: "ok",
-			itemId: safeId,
-			item
-		};
-	}
-	await writeFileAtomic(filePath, payload);
+	} else await writeFileAtomic(filePath, payload);
+	if (opts.slug) publishCollectionChange({
+		slug: opts.slug,
+		ids: [safeId],
+		op: "upsert"
+	});
 	return {
 		kind: "ok",
 		itemId: safeId,
@@ -426,6 +442,11 @@ async function deleteItem(dataDir, itemId, opts = {}) {
 	const filePath = itemFilePath(dataDir, safeId);
 	try {
 		await (0, node_fs_promises.unlink)(filePath);
+		if (opts.slug) publishCollectionChange({
+			slug: opts.slug,
+			ids: [safeId],
+			op: "delete"
+		});
 		return {
 			kind: "ok",
 			itemId: safeId
@@ -780,7 +801,7 @@ var CustomViewSchema = zod.z.object({
 	file: zod.z.string().trim().min(1).refine(isSafeCustomViewPath, "must be a safe path under `views/` ending in `.html` (e.g. `views/year.html`; no `..`, no leading `/`, no backslash)"),
 	capabilities: zod.z.array(zod.z.enum(["read", "write"])).optional()
 });
-var EverySchema = zod.z.object({
+var EveryLiteralSchema = zod.z.object({
 	unit: zod.z.enum([
 		"day",
 		"week",
@@ -789,7 +810,12 @@ var EverySchema = zod.z.object({
 	]),
 	interval: zod.z.number().int().min(1),
 	dayOfMonth: zod.z.union([zod.z.number().int().min(1).max(31), zod.z.literal("last")]).optional()
-});
+}).strict();
+var EveryFieldDrivenSchema = zod.z.object({
+	fromField: zod.z.string().trim().min(1),
+	map: zod.z.record(zod.z.string(), EveryLiteralSchema)
+}).strict();
+var EverySchema = zod.z.union([EveryLiteralSchema, EveryFieldDrivenSchema]);
 var SpawnSchema = zod.z.object({
 	when: WhenSchema.optional(),
 	every: EverySchema,
@@ -831,6 +857,36 @@ function spawnSuccessorStartsInert(schema) {
 	if (spawn.set && Object.prototype.hasOwnProperty.call(spawn.set, field)) return !values.includes(String(spawn.set[field]));
 	return !(spawn.carry ?? []).includes(field);
 }
+function fieldDrivenSpawnEvery(schema) {
+	const every = schema.spawn?.every;
+	if (!every || !require_schema.isFieldDrivenEvery(every)) return null;
+	return every;
+}
+function fieldDrivenFromFieldIsEnum(schema) {
+	const driven = fieldDrivenSpawnEvery(schema);
+	if (!driven) return true;
+	return schema.fields[driven.fromField]?.type === "enum";
+}
+function fieldDrivenMapCoversValues(schema) {
+	const driven = fieldDrivenSpawnEvery(schema);
+	if (!driven) return true;
+	const target = schema.fields[driven.fromField];
+	if (!target || target.type !== "enum" || target.values === void 0) return true;
+	const values = new Set(target.values);
+	const keys = Object.keys(driven.map);
+	return keys.length === values.size && keys.every((key) => values.has(key));
+}
+function fieldDrivenFromFieldCarried(schema) {
+	const driven = fieldDrivenSpawnEvery(schema);
+	if (!driven) return true;
+	const { carry, set } = schema.spawn ?? {};
+	if (set && Object.prototype.hasOwnProperty.call(set, driven.fromField)) {
+		const raw = set[driven.fromField];
+		if (raw === void 0 || raw === null || raw === "") return false;
+		return Object.prototype.hasOwnProperty.call(driven.map, String(raw));
+	}
+	return (carry ?? []).includes(driven.fromField);
+}
 var IngestSchemaZ = zod.z.object({
 	kind: zod.z.enum(require_schema.INGEST_KINDS),
 	url: zod.z.string().url(),
@@ -907,6 +963,15 @@ var CollectionSchemaZ = zod.z.object({
 }).refine((schema) => spawnSuccessorStartsInert(schema), {
 	message: "`spawn` must leave the successor in a non-matching state (e.g. `set` the status to a pending value); seeding the predicate field to a matching value via `set`/`carry` would respawn forever",
 	path: ["spawn"]
+}).refine((schema) => fieldDrivenFromFieldIsEnum(schema), {
+	message: "`spawn.every.fromField` must name a top-level `enum` field declared in `fields`",
+	path: ["spawn"]
+}).refine((schema) => fieldDrivenMapCoversValues(schema), {
+	message: "`spawn.every.map` keys must exactly cover the `values` of the `enum` named by `fromField` (no missing or extra keys)",
+	path: ["spawn"]
+}).refine((schema) => fieldDrivenFromFieldCarried(schema), {
+	message: "`spawn.every.fromField` must appear in `spawn.carry`, or be written by `spawn.set` to a value present in `spawn.every.map`, so the successor keeps a resolvable recurrence interval",
+	path: ["spawn"]
 }).refine((schema) => schema.calendarField === void 0 || isDateLike(schema.fields[schema.calendarField]?.type), {
 	message: "schema `calendarField` must name a top-level `date` or `datetime` field declared in `fields`",
 	path: ["calendarField"]
@@ -1313,6 +1378,18 @@ function matchesWhen(when, schema, item) {
 	const raw = item[completionField];
 	return raw !== void 0 && raw !== null && completionDoneValues.includes(String(raw));
 }
+/** Resolve the literal `every` that applies to `sourceItem`. Literal-arm
+*  `spawn.every` passes through unchanged. Field-driven `spawn.every` reads
+*  `sourceItem[fromField]` and looks it up in `map`; an empty field or a
+*  value with no map entry yields null (caller skips + logs — see plan §5).
+*  Discovery rejects a map that doesn't cover the enum's values, so null
+*  here means a record that predates a map/enum edit. */
+function resolveEvery(every, sourceItem) {
+	if (!require_schema.isFieldDrivenEvery(every)) return every;
+	const raw = sourceItem[every.fromField];
+	if (raw === void 0 || raw === null || raw === "") return null;
+	return every.map[String(raw)] ?? null;
+}
 /** Build the successor record purely from (schema, source record, source
 *  id). Returns null when the schema has no spawn/triggerField or the
 *  source's trigger date is unparseable. */
@@ -1321,7 +1398,9 @@ function computeSuccessor(schema, sourceItem, sourceId) {
 	if (!spawn || !triggerField) return null;
 	const srcDate = parseCivil(sourceItem[triggerField]);
 	if (srcDate === null) return null;
-	const next = advanceTriggerDate(srcDate, spawn.every);
+	const every = resolveEvery(spawn.every, sourceItem);
+	if (every === null) return null;
+	const next = advanceTriggerDate(srcDate, every);
 	const nextId = successorId(sourceId, next);
 	const record = {};
 	for (const field of spawn.carry ?? []) if (Object.prototype.hasOwnProperty.call(sourceItem, field)) record[field] = sourceItem[field];
@@ -1333,6 +1412,27 @@ function computeSuccessor(schema, sourceItem, sourceId) {
 		record
 	};
 }
+/** Warn precisely about which of `computeSuccessor`'s two null causes fired
+*  (plan §5): an unparseable source trigger date (the original cause), or a
+*  field-driven `every` whose record value has no `map` entry (a record that
+*  predates a map/enum edit — discovery rejects this statically otherwise). */
+function logSpawnSkip(slug, triggerField, every, sourceItem, sourceId) {
+	if (parseCivil(sourceItem[triggerField]) === null) {
+		log.warn("collections", "spawn skipped: source trigger date unparseable", {
+			slug,
+			sourceId,
+			triggerField
+		});
+		return;
+	}
+	const fromField = require_schema.isFieldDrivenEvery(every) ? every.fromField : void 0;
+	log.warn("collections", "spawn skipped: no `every` mapping for frequency value", {
+		slug,
+		sourceId,
+		fromField,
+		value: fromField === void 0 ? void 0 : sourceItem[fromField]
+	});
+}
 /** Idempotently create the successor for `sourceItem` when it matches the
 *  spawn predicate. No-op when the schema declares no spawn, the
 *  predicate doesn't match, the trigger date is unparseable, or the
@@ -1344,11 +1444,7 @@ async function maybeSpawnSuccessor(slug, schema, dataDir, sourceItem, sourceId,
 	if (!matchesWhen(spawn.when, schema, sourceItem)) return;
 	const computed = computeSuccessor(schema, sourceItem, sourceId);
 	if (computed === null) {
-		log.warn("collections", "spawn skipped: source trigger date unparseable", {
-			slug,
-			sourceId,
-			triggerField: schema.triggerField
-		});
+		logSpawnSkip(slug, schema.triggerField, spawn.every, sourceItem, sourceId);
 		return;
 	}
 	if (matchesWhen(spawn.when, schema, computed.record)) {
@@ -1362,7 +1458,8 @@ async function maybeSpawnSuccessor(slug, schema, dataDir, sourceItem, sourceId,
 	try {
 		const result = await writeItem(dataDir, computed.id, computed.record, {
 			...ioOpts,
-			refuseOverwrite: true
+			refuseOverwrite: true,
+			slug
 		});
 		if (result.kind === "ok") log.info("collections", "spawned successor", {
 			slug,
@@ -1641,14 +1738,17 @@ exports.loadCollection = loadCollection;
 exports.log = log;
 exports.maybeSpawnSuccessor = maybeSpawnSuccessor;
 exports.parseCivil = parseCivil;
+exports.publishCollectionChange = publishCollectionChange;
 exports.readCustomViewHtml = readCustomViewHtml;
 exports.readItem = readItem;
 exports.readSkillTemplate = readSkillTemplate;
 exports.resolveCreateItemId = resolveCreateItemId;
 exports.resolveDataDir = resolveDataDir;
+exports.resolveEvery = resolveEvery;
 exports.resolveTemplatePath = resolveTemplatePath;
 exports.safeRecordId = safeRecordId;
 exports.safeSlugName = safeSlugName;
+exports.setCollectionChangePublisher = setCollectionChangePublisher;
 exports.successorId = successorId;
 exports.toDetail = toDetail;
 exports.toSummary = toSummary;