@mulmoclaude/core 0.1.0

package/dist/collection/index.js

@@ -0,0 +1,740 @@
+import { a as INGEST_KINDS, i as FEED_SCHEDULES, n as resolveRowRefs, o as isFieldDrivenEvery, r as evaluateDerived, t as deriveAll } from "../deriveAll-C6BYnpBL.js";
+//#region src/collection/core/presentCollection.ts
+var TOOL_NAME = "presentCollection";
+var TOOL_DEFINITION = {
+	type: "function",
+	name: TOOL_NAME,
+	description: "Display a schema-driven collection inline in the chat as an interactive, editable card. Shows the collection's list of records. Pass `itemId` to open one specific record on mount.",
+	parameters: {
+		type: "object",
+		properties: {
+			collectionSlug: {
+				type: "string",
+				description: "The slug of the collection to display (e.g. 'clients', 'invoices', 'contacts')."
+			},
+			itemId: {
+				type: "string",
+				description: "Optional primary-key value of a single record to open in detail view on mount. Omit to show the full list."
+			}
+		},
+		required: ["collectionSlug"]
+	},
+	prompt: `After making changes to schema-driven collections, use ${TOOL_NAME} to present either the collection or the item`
+};
+var executePresentCollection = async (_context, args) => {
+	const collectionSlug = typeof args?.collectionSlug === "string" ? args.collectionSlug.trim() : "";
+	if (!collectionSlug) return {
+		message: "presentCollection error: collectionSlug is required",
+		instructions: "Tell the user you couldn't display the collection because no collection was specified, and ask which collection they mean."
+	};
+	const itemId = typeof args.itemId === "string" && args.itemId.trim().length > 0 ? args.itemId.trim() : void 0;
+	const data = itemId ? {
+		collectionSlug,
+		itemId
+	} : { collectionSlug };
+	return {
+		message: `Presented collection ${itemId ? `${collectionSlug} / ${itemId}` : collectionSlug}`,
+		data,
+		jsonData: data,
+		instructions: "The collection has been presented to the user as an interactive card. They can browse, open, edit, create, and delete records directly. No further action is needed unless they ask."
+	};
+};
+//#endregion
+//#region src/collection/core/enumColors.ts
+var PALETTE = [
+	{
+		card: "border-indigo-200 bg-indigo-50 text-indigo-600 hover:bg-indigo-100",
+		dot: "bg-indigo-500",
+		badge: "bg-indigo-100 text-indigo-700",
+		border: "border-indigo-200"
+	},
+	{
+		card: "border-sky-200 bg-sky-50 text-sky-600 hover:bg-sky-100",
+		dot: "bg-sky-500",
+		badge: "bg-sky-100 text-sky-700",
+		border: "border-sky-200"
+	},
+	{
+		card: "border-cyan-200 bg-cyan-50 text-cyan-600 hover:bg-cyan-100",
+		dot: "bg-cyan-500",
+		badge: "bg-cyan-100 text-cyan-700",
+		border: "border-cyan-200"
+	},
+	{
+		card: "border-teal-200 bg-teal-50 text-teal-600 hover:bg-teal-100",
+		dot: "bg-teal-500",
+		badge: "bg-teal-100 text-teal-700",
+		border: "border-teal-200"
+	},
+	{
+		card: "border-emerald-200 bg-emerald-50 text-emerald-600 hover:bg-emerald-100",
+		dot: "bg-emerald-500",
+		badge: "bg-emerald-100 text-emerald-700",
+		border: "border-emerald-200"
+	},
+	{
+		card: "border-lime-200 bg-lime-50 text-lime-600 hover:bg-lime-100",
+		dot: "bg-lime-500",
+		badge: "bg-lime-100 text-lime-700",
+		border: "border-lime-200"
+	},
+	{
+		card: "border-violet-200 bg-violet-50 text-violet-600 hover:bg-violet-100",
+		dot: "bg-violet-500",
+		badge: "bg-violet-100 text-violet-700",
+		border: "border-violet-200"
+	},
+	{
+		card: "border-fuchsia-200 bg-fuchsia-50 text-fuchsia-600 hover:bg-fuchsia-100",
+		dot: "bg-fuchsia-500",
+		badge: "bg-fuchsia-100 text-fuchsia-700",
+		border: "border-fuchsia-200"
+	}
+];
+/** Neutral styling for the empty / Uncategorized bucket — never a palette
+*  colour, so an unset or unknown value reads grey across every surface. */
+var ENUM_NEUTRAL = {
+	card: "border-slate-200 bg-slate-50 text-slate-500 hover:bg-slate-100",
+	dot: "bg-slate-300",
+	badge: "bg-slate-100 text-slate-500",
+	border: "border-slate-200"
+};
+/** The urgent notification colour (red), matching the bell's `urgent`
+*  severity. The first value a schema's `notifyWhen` flags reads this. */
+var ENUM_ALERT = {
+	card: "border-red-200 bg-red-50 text-red-600 hover:bg-red-100",
+	dot: "bg-red-500",
+	badge: "bg-red-100 text-red-700",
+	border: "border-red-200"
+};
+/** The nudge notification colour (amber), matching the bell's `nudge`
+*  severity. Flagged `notifyWhen` values after the first read this. */
+var ENUM_NUDGE = {
+	card: "border-amber-200 bg-amber-50 text-amber-600 hover:bg-amber-100",
+	dot: "bg-amber-500",
+	badge: "bg-amber-100 text-amber-700",
+	border: "border-amber-200"
+};
+/** Classes for the enum value at `index` in its field's `values` array. A
+*  negative index (value unset or not among the declared values) reads
+*  neutral. */
+function enumColorClasses(index) {
+	if (index < 0) return ENUM_NEUTRAL;
+	return PALETTE[index % PALETTE.length] ?? ENUM_NEUTRAL;
+}
+/** Index of `value` within an enum field's declared `values`, or -1 when the
+*  value is empty / unknown (→ neutral). */
+function enumValueIndex(values, value) {
+	if (value === void 0 || value === null || value === "") return -1;
+	return values?.indexOf(String(value)) ?? -1;
+}
+/** The flagged values when `fieldKey` is the schema's `notifyWhen` target (the
+*  "notification enum"); undefined for every other field. */
+function notifyValuesFor(schema, fieldKey) {
+	const spec = schema.notifyWhen;
+	return spec && spec.field === fieldKey ? spec.in : void 0;
+}
+/** Resolve a value's colour for enum field `fieldKey`:
+*  - Notification enum (`notifyWhen` targets it): the first flagged value (in
+*    `notifyWhen.in` order, the most urgent) reads notification red, the rest
+*    amber, and every non-flagged value neutral grey.
+*  - Any other enum: the standard palette by the value's declared index. */
+function resolveEnumColor(schema, fieldKey, value) {
+	const notifyValues = notifyValuesFor(schema, fieldKey);
+	if (notifyValues) {
+		const str = value === void 0 || value === null ? "" : String(value);
+		const rank = notifyValues.indexOf(str);
+		if (rank < 0) return ENUM_NEUTRAL;
+		return rank === 0 ? ENUM_ALERT : ENUM_NUDGE;
+	}
+	return enumColorClasses(enumValueIndex(schema.fields[fieldKey]?.values, value));
+}
+//#endregion
+//#region src/collection/core/actionVisible.ts
+/** Core matcher:
+*  - no `when` ⇒ always true (visible);
+*  - otherwise true only when `record[when.field]` is present and its
+*    stringified value is one of `when.in`.
+*  A missing/undefined/null field is treated as "not a match"
+*  (hidden), so a status-gated target never shows on a record that
+*  lacks the status. */
+function whenMatches(when, record) {
+	if (!when) return true;
+	const value = record[when.field];
+	if (value === void 0 || value === null) return false;
+	return when.in.includes(String(value));
+}
+/** True when the action's button should render against `record`
+*  (see whenMatches). */
+function actionVisible(action, record) {
+	return whenMatches(action.when, record);
+}
+/** True when the field should render against `record`. A field with
+*  no `when` is always shown; otherwise it's shown only when the
+*  record matches (e.g. hide a rating field until `visited` is true).
+*  Purely presentational — a hidden field's stored value is never
+*  altered, so toggling the gate back on restores it. */
+function fieldVisible(field, record) {
+	return whenMatches(field.when, record);
+}
+//#endregion
+//#region src/collection/core/draft.ts
+/** A fresh, empty row draft for a `table` field's sub-schema. */
+function emptyRow(subFields) {
+	const text = {};
+	const bool = {};
+	const boolOriginallyPresent = {};
+	const boolTouched = {};
+	for (const [subKey, subField] of Object.entries(subFields)) if (subField.type === "boolean") {
+		bool[subKey] = false;
+		boolOriginallyPresent[subKey] = false;
+		boolTouched[subKey] = false;
+	} else text[subKey] = "";
+	return {
+		text,
+		bool,
+		boolOriginallyPresent,
+		boolTouched
+	};
+}
+/** Build a row draft from an existing persisted row. */
+function rowFromItem(item, subFields) {
+	const text = {};
+	const bool = {};
+	const boolOriginallyPresent = {};
+	const boolTouched = {};
+	for (const [subKey, subField] of Object.entries(subFields)) {
+		const raw = item[subKey];
+		if (subField.type === "boolean") {
+			bool[subKey] = raw === true;
+			boolOriginallyPresent[subKey] = typeof raw === "boolean";
+			boolTouched[subKey] = false;
+		} else text[subKey] = raw === void 0 || raw === null ? "" : String(raw);
+	}
+	return {
+		text,
+		bool,
+		boolOriginallyPresent,
+		boolTouched
+	};
+}
+/** Decide whether a boolean field's draft value should be emitted (vs.
+*  omitted so a downstream default applies). */
+function shouldEmitBoolean(state, key, field) {
+	return Boolean(state.boolOriginallyPresent[key] || state.boolTouched[key] || field.required);
+}
+/** Convert a scalar draft slot to its persisted form. `undefined` = omit. */
+function scalarDraftToValue(raw, fieldType) {
+	if (raw === void 0 || raw === "") return void 0;
+	if (fieldType === "number" || fieldType === "money") {
+		const num = Number(raw);
+		return Number.isFinite(num) ? num : raw;
+	}
+	return raw;
+}
+/** Convert one table row draft to its persisted record. */
+function rowDraftToRecord(rowDraft, subFields) {
+	const row = {};
+	for (const [subKey, subField] of Object.entries(subFields)) {
+		if (subField.type === "boolean") {
+			const value = rowDraft.bool[subKey] === true;
+			if (rowDraft.boolOriginallyPresent[subKey] || rowDraft.boolTouched[subKey] || value || subField.required) row[subKey] = value;
+			continue;
+		}
+		const value = scalarDraftToValue(rowDraft.text[subKey], subField.type);
+		if (value !== void 0) row[subKey] = value;
+	}
+	return row;
+}
+/** Convert a full edit draft to the record to persist. */
+function draftToRecord(state, schema) {
+	const record = {};
+	for (const [key, field] of Object.entries(schema.fields)) {
+		if (field.type === "derived" || field.type === "embed" || field.type === "toggle") continue;
+		if (field.type === "boolean") {
+			if (shouldEmitBoolean(state, key, field)) record[key] = state.bool[key] === true;
+			continue;
+		}
+		if (field.type === "table" && field.of) {
+			const subFields = field.of;
+			record[key] = (state.table[key] ?? []).map((rowDraft) => rowDraftToRecord(rowDraft, subFields));
+			continue;
+		}
+		const value = scalarDraftToValue(state.text[key], field.type);
+		if (value !== void 0) record[key] = value;
+	}
+	return record;
+}
+/** Normalise a raw inline-edit input (table-cell checkbox/select) to its
+*  persisted form. Mirrors `draftToRecord`'s boolean strictness; an empty
+*  enum selection (the placeholder option) clears the field via `undefined`. */
+function coerceInlineValue(field, raw) {
+	if (field.type === "boolean") return raw === true;
+	return raw === "" ? void 0 : raw;
+}
+/** Build the full record to PUT for a single-cell inline edit, without
+*  mutating `item`. A `undefined` value omits the key (enum cleared),
+*  matching `draftToRecord`'s omission semantics. */
+function buildUpdatedRecord(item, key, value) {
+	if (value === void 0) {
+		const { [key]: __omit, ...rest } = item;
+		return rest;
+	}
+	return {
+		...item,
+		[key]: value
+	};
+}
+/** Empty for required-field validation — NOT a truthiness check (a
+*  numeric `0` is a filled value). */
+function isMissingDraftValue(value) {
+	return value === void 0 || value === null || value === "";
+}
+/** Label of the first required table sub-field empty in any row, else null. */
+function firstMissingTableSubField(field, rows) {
+	if (!field.of || !rows) return null;
+	for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
+		const row = rows[rowIdx];
+		for (const [subKey, subField] of Object.entries(field.of)) {
+			if (!subField.required || subField.type === "boolean") continue;
+			if (isMissingDraftValue(row.text[subKey])) return `${field.label} #${rowIdx + 1}: ${subField.label}`;
+		}
+	}
+	return null;
+}
+function validateOneField(key, field, draft, record) {
+	if (!fieldVisible(field, record)) return null;
+	if (field.type === "table" && field.of) {
+		const rows = draft.table[key];
+		if (field.required && (!rows || rows.length === 0)) return field.label;
+		return firstMissingTableSubField(field, rows);
+	}
+	if (!field.required) return null;
+	if (draft.mode === "create" && field.primary === true) return null;
+	if (field.type === "boolean" || field.type === "derived" || field.type === "embed" || field.type === "toggle") return null;
+	return isMissingDraftValue(draft.text[key]) ? field.label : null;
+}
+/** Human-readable label of the first missing required field, or null. */
+function firstMissingRequiredField(draft, schema) {
+	const record = draftToRecord(draft, schema);
+	for (const [key, field] of Object.entries(schema.fields)) {
+		const missing = validateOneField(key, field, draft, record);
+		if (missing) return missing;
+	}
+	return null;
+}
+//#endregion
+//#region src/collection/core/sortItems.ts
+var EMPTY = { empty: true };
+/** Field types that render no value text in the table, so offer no sort. */
+var NON_SORTABLE = new Set([
+	"markdown",
+	"table",
+	"image",
+	"file",
+	"embed"
+]);
+function isSortableField(field) {
+	return !NON_SORTABLE.has(field.type);
+}
+/** Cycle one column's state: none → asc → desc → none. */
+function nextSortDirection(current) {
+	if (current === null) return "asc";
+	if (current === "asc") return "desc";
+	return null;
+}
+function numericSortValue(raw) {
+	if (raw == null || raw === "") return EMPTY;
+	const num = typeof raw === "number" ? raw : Number(raw);
+	return Number.isFinite(num) ? {
+		empty: false,
+		num
+	} : EMPTY;
+}
+function stringSortValue(raw) {
+	if (raw == null) return EMPTY;
+	const str = String(raw);
+	return str.trim() === "" ? EMPTY : {
+		empty: false,
+		str
+	};
+}
+function dateSortValue(raw) {
+	if (raw == null || raw === "") return EMPTY;
+	const epoch = Date.parse(String(raw));
+	return Number.isNaN(epoch) ? stringSortValue(raw) : {
+		empty: false,
+		num: epoch
+	};
+}
+/** Enum sorts by the value's index in the declared `values` list. A value
+*  outside the list (or unset) is treated as empty → last. */
+function enumSortValue(values, raw) {
+	if (raw == null || raw === "") return EMPTY;
+	const idx = values ? values.indexOf(String(raw)) : -1;
+	return idx < 0 ? EMPTY : {
+		empty: false,
+		num: idx
+	};
+}
+/** Boolean / toggle: false < true, never empty (unset reads as false). */
+function boolSortValue(checked) {
+	return {
+		empty: false,
+		num: checked ? 1 : 0
+	};
+}
+function compareSortValues(left, right) {
+	if (left.num !== void 0 && right.num !== void 0) return left.num - right.num;
+	const leftStr = left.str ?? String(left.num ?? "");
+	const rightStr = right.str ?? String(right.num ?? "");
+	return leftStr.localeCompare(rightStr);
+}
+/** Stable sort of `items` by `valueOf`. Empties always last; ties hold
+*  source order. Returns a new array (does not mutate `items`). */
+function sortItems(items, direction, valueOf) {
+	const dir = direction === "asc" ? 1 : -1;
+	return items.map((item, index) => ({
+		item,
+		index,
+		sv: valueOf(item)
+	})).sort((left, right) => {
+		if (left.sv.empty || right.sv.empty) {
+			if (left.sv.empty && right.sv.empty) return left.index - right.index;
+			return left.sv.empty ? 1 : -1;
+		}
+		const base = compareSortValues(left.sv, right.sv);
+		return base !== 0 ? base * dir : left.index - right.index;
+	}).map((decorated) => decorated.item);
+}
+//#endregion
+//#region src/collection/core/itemLabel.ts
+var LABEL_FIELD_TYPES = new Set([
+	"string",
+	"text",
+	"markdown",
+	"email"
+]);
+/** Which field labels a record: the schema's explicit `displayField`, else the
+*  first non-primary text-like field (so a collection without a displayField
+*  shows e.g. the title rather than the opaque primaryKey), else null → the
+*  caller falls back to the primary-key value. */
+function labelFieldFor(schema) {
+	if (schema.displayField) return schema.displayField;
+	for (const [key, spec] of Object.entries(schema.fields)) if (key !== schema.primaryKey && LABEL_FIELD_TYPES.has(spec.type)) return key;
+	return null;
+}
+/** A record's primary-key value as a string. */
+function itemIdOf(item, schema) {
+	return String(item[schema.primaryKey] ?? "");
+}
+/** A record's display label: the resolved `labelField` value, else the
+*  primary key. Pass the result of `labelFieldFor(schema)` as `labelField`
+*  (compute it once per render rather than per item). */
+function itemLabelOf(item, schema, labelField) {
+	if (labelField) {
+		const value = item[labelField];
+		if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+			const text = String(value);
+			if (text.length > 0) return text;
+		}
+	}
+	return itemIdOf(item, schema);
+}
+//#endregion
+//#region src/collection/core/calendarGrid.ts
+var MS_PER_DAY = 864e5;
+var ISO_DATE_RE = /^(\d{4})-(\d{2})-(\d{2})$/;
+var TWO_DIGIT_RE = /^\d{2}$/;
+var CLOCK_RE = /(\d{1,2}):(\d{2})/g;
+var RANGE_SEP_RE = /[-–—~〜～]/;
+/** Minutes in a full day — the timeline's vertical extent. */
+var MINUTES_PER_DAY = 1440;
+function pad2(value) {
+	return String(value).padStart(2, "0");
+}
+/** Canonical `YYYY-MM-DD` string for a civil date. */
+function ymdKey(ymd) {
+	return `${String(ymd.year).padStart(4, "0")}-${pad2(ymd.month)}-${pad2(ymd.day)}`;
+}
+/** Strictly parse a `YYYY-MM-DD` string into a civil date, rejecting
+*  anything that isn't a real calendar day (e.g. `2026-02-30`, `2026-13-01`).
+*  Returns null for non-strings and malformed values so callers can route
+*  records with no usable date into the "no date" tray rather than crash. */
+function parseIsoDate(value) {
+	if (typeof value !== "string") return null;
+	const match = ISO_DATE_RE.exec(value.trim());
+	if (!match) return null;
+	const year = Number(match[1]);
+	const month = Number(match[2]);
+	const day = Number(match[3]);
+	const probe = new Date(Date.UTC(year, month - 1, day));
+	if (probe.getUTCFullYear() !== year || probe.getUTCMonth() !== month - 1 || probe.getUTCDate() !== day) return null;
+	return {
+		year,
+		month,
+		day
+	};
+}
+/** Minutes-of-day for an `HH:MM` pair, or null when out of range. */
+function clockToMinutes(hours, minutes) {
+	if (hours < 0 || hours > 23 || minutes < 0 || minutes > 59) return null;
+	return hours * 60 + minutes;
+}
+/** Strictly parse a `YYYY-MM-DDTHH:MM` (optional `:SS`) datetime into its
+*  civil date and minutes-of-day. Returns null for anything that isn't a real
+*  calendar day or a valid 24h clock. */
+function parseIsoDateTime(value) {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	const tIndex = trimmed.indexOf("T");
+	if (tIndex === -1) return null;
+	const ymd = parseIsoDate(trimmed.slice(0, tIndex));
+	if (!ymd) return null;
+	const parts = trimmed.slice(tIndex + 1).split(":");
+	if (parts.length < 2 || parts.length > 3 || !parts.every((part) => TWO_DIGIT_RE.test(part))) return null;
+	const minutes = clockToMinutes(Number(parts[0]), Number(parts[1]));
+	if (minutes === null) return null;
+	return {
+		ymd,
+		minutes
+	};
+}
+/** Civil date from either a `YYYY-MM-DD` or a `YYYY-MM-DDTHH:MM` value, so the
+*  month grid buckets date-only and datetime anchors alike. */
+function dateOf(value) {
+	return parseIsoDate(value) ?? parseIsoDateTime(value)?.ymd ?? null;
+}
+/** Minutes-of-day from a datetime value, or null for date-only / invalid. */
+function timeOf(value) {
+	return parseIsoDateTime(value)?.minutes ?? null;
+}
+/** Parse a free-form time-string field into start/end minutes-of-day.
+*  Handles the common shapes in user data:
+*    "14:00-17:00" → { start: 840, end: 1020 }   (range → block)
+*    "17:00-"      → { start: 1020, end: null }   (open end → single line)
+*    "16:30"       → { start: 990, end: null }    (point in time → single line)
+*    "終日" / ""   → null                          (no clock → all-day)
+*  Returns null when no clock token is parseable. */
+function parseTimeRange(value) {
+	if (typeof value !== "string") return null;
+	const text = value.trim();
+	if (!text) return null;
+	const tokens = [...text.matchAll(CLOCK_RE)];
+	if (tokens.length === 0) return null;
+	const minutesOf = (match) => clockToMinutes(Number(match[1]), Number(match[2]));
+	if (!RANGE_SEP_RE.test(text)) {
+		const startMin = minutesOf(tokens[0]);
+		return startMin === null ? null : {
+			startMin,
+			endMin: null
+		};
+	}
+	const sepIndex = text.search(RANGE_SEP_RE);
+	let startMin = null;
+	let endMin = null;
+	for (const token of tokens) if ((token.index ?? 0) < sepIndex) startMin = minutesOf(token);
+	else endMin = minutesOf(token);
+	if (startMin === null) return null;
+	return {
+		startMin,
+		endMin
+	};
+}
+function ymdToUtcMs(ymd) {
+	return Date.UTC(ymd.year, ymd.month - 1, ymd.day);
+}
+function utcMsToYmd(epochMs) {
+	const date = new Date(epochMs);
+	return {
+		year: date.getUTCFullYear(),
+		month: date.getUTCMonth() + 1,
+		day: date.getUTCDate()
+	};
+}
+/** Chronological comparison: negative if `left` precedes `right`, 0 if the
+*  same day, positive if after. */
+function compareYmd(left, right) {
+	return ymdToUtcMs(left) - ymdToUtcMs(right);
+}
+/** True iff `day` falls within the inclusive span `[span.start, span.end]`. */
+function spanCoversDay(span, day) {
+	return compareYmd(span.start, day) <= 0 && compareYmd(day, span.end) <= 0;
+}
+/** Build the 6×7 (42-cell) grid for the given month, including the
+*  leading/trailing days of the adjacent months so every week is full.
+*  `month` is 1-12. `weekStartsOn` is 0 (Sunday) … 6 (Saturday). */
+function buildMonthGrid(year, month, weekStartsOn = 0) {
+	const lead = (new Date(Date.UTC(year, month - 1, 1)).getUTCDay() - weekStartsOn + 7) % 7;
+	const startMs = Date.UTC(year, month - 1, 1) - lead * MS_PER_DAY;
+	const cells = [];
+	for (let i = 0; i < 42; i++) {
+		const ymd = utcMsToYmd(startMs + i * MS_PER_DAY);
+		cells.push({
+			ymd,
+			inMonth: ymd.year === year && ymd.month === month,
+			key: ymdKey(ymd)
+		});
+	}
+	return cells;
+}
+/** Resolve a record's calendar span from its date/datetime fields. Returns
+*  null when the anchor date is missing/invalid (→ the caller's "no date"
+*  tray). An end date that is missing, invalid, or earlier than the start
+*  collapses to a single-day span — never an inverted range.
+*
+*  Times for the day (time-allocation) view come from, in priority order:
+*    1. the clock on a `datetime` anchor/end value, else
+*    2. `timeField` — a separate free-form time-string column (e.g. "14:00-17:00").
+*  A record with no resolvable clock has `startMin === endMin === null`. */
+function recordSpan(item, anchorField, endField, timeField) {
+	const startRaw = item[anchorField];
+	const start = dateOf(startRaw);
+	if (!start) return null;
+	let end = start;
+	let startMin = timeOf(startRaw);
+	let endMin = null;
+	if (endField) {
+		const endRaw = item[endField];
+		const parsedEnd = dateOf(endRaw);
+		if (parsedEnd && compareYmd(parsedEnd, start) >= 0) {
+			end = parsedEnd;
+			endMin = timeOf(endRaw);
+		}
+	}
+	if (timeField && startMin === null && endMin === null) {
+		const range = parseTimeRange(item[timeField]);
+		if (range) ({startMin, endMin} = range);
+	}
+	return {
+		item,
+		start,
+		end,
+		startMin,
+		endMin
+	};
+}
+/** Split records into those that land on the calendar (with their spans)
+*  and those with no usable anchor date (the "no date" tray). Spans are
+*  sorted by start day so same-day stacking is stable across renders. */
+function bucketRecords(items, anchorField, endField, timeField) {
+	const spans = [];
+	const noDate = [];
+	for (const item of items) {
+		const span = recordSpan(item, anchorField, endField, timeField);
+		if (span) spans.push(span);
+		else noDate.push(item);
+	}
+	spans.sort((left, right) => compareYmd(left.start, right.start));
+	return {
+		spans,
+		noDate
+	};
+}
+/** Project a record's span onto a single day for the time-allocation view, or
+*  null when the span doesn't cover that day. */
+function daySlice(span, day) {
+	if (!spanCoversDay(span, day)) return null;
+	const hasStart = span.startMin !== null;
+	const hasEnd = span.endMin !== null;
+	if (!hasStart && !hasEnd) return {
+		kind: "allDay",
+		startMin: 0,
+		endMin: MINUTES_PER_DAY,
+		bleedsBefore: false,
+		bleedsAfter: false
+	};
+	const singleDay = compareYmd(span.start, span.end) === 0;
+	const isStartDay = compareYmd(day, span.start) === 0;
+	const isEndDay = compareYmd(day, span.end) === 0;
+	if (singleDay && hasStart && !hasEnd) return {
+		kind: "line",
+		startMin: span.startMin,
+		endMin: span.startMin,
+		bleedsBefore: false,
+		bleedsAfter: false
+	};
+	const startMin = isStartDay && hasStart ? span.startMin : 0;
+	const endMin = isEndDay && hasEnd ? span.endMin : MINUTES_PER_DAY;
+	if (singleDay && endMin <= startMin) return {
+		kind: "line",
+		startMin,
+		endMin: startMin,
+		bleedsBefore: false,
+		bleedsAfter: false
+	};
+	return {
+		kind: "block",
+		startMin,
+		endMin,
+		bleedsBefore: !isStartDay,
+		bleedsAfter: !isEndDay
+	};
+}
+function assignLanes(blocks) {
+	const order = [...blocks.keys()].sort((left, right) => blocks[left].startMin - blocks[right].startMin || blocks[left].endMin - blocks[right].endMin);
+	const result = blocks.map(() => ({
+		lane: 0,
+		lanes: 1
+	}));
+	let cluster = [];
+	let clusterEnd = Number.NEGATIVE_INFINITY;
+	const laneEnds = [];
+	const flush = () => {
+		for (const index of cluster) result[index].lanes = laneEnds.length;
+		cluster = [];
+		laneEnds.length = 0;
+		clusterEnd = Number.NEGATIVE_INFINITY;
+	};
+	for (const index of order) {
+		const block = blocks[index];
+		if (cluster.length > 0 && block.startMin >= clusterEnd) flush();
+		let lane = laneEnds.findIndex((end) => end <= block.startMin);
+		if (lane === -1) {
+			lane = laneEnds.length;
+			laneEnds.push(block.endMin);
+		} else laneEnds[lane] = block.endMin;
+		result[index].lane = lane;
+		cluster.push(index);
+		clusterEnd = Math.max(clusterEnd, block.endMin);
+	}
+	flush();
+	return result;
+}
+/** Month label key inputs — returns the 1st of the month as a `Date` so the
+*  component can feed it to `Intl.DateTimeFormat(locale, …)` for a localized
+*  "April 2026" header without this module taking a locale dependency. */
+function monthAnchorDate(year, month) {
+	return new Date(Date.UTC(year, month - 1, 1));
+}
+//#endregion
+//#region src/collection/core/errorMessage.ts
+/** Normalise an unknown thrown value to a display string. The view layer's host
+*  capabilities already return normalised `{ ok: false, error }` results, so this
+*  only backs the defensive `catch` around an unexpected throw. */
+function errorMessage(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+//#endregion
+//#region src/collection/core/shortHexId.ts
+/**
+* 8-char hex id — short, slug-safe, and editable. Produces the same id *shape*
+* as the server's `generateItemId()` (8 hex chars) so a UI-created collection
+* record looks like one the server would have generated for a form submitted
+* with a blank primary key. The source of randomness differs (UUID-derived here
+* vs `randomBytes` on the server); only the shape is intentionally shared.
+*/
+function shortHexId() {
+	return crypto.randomUUID().replace(/-/g, "").slice(0, 8);
+}
+//#endregion
+//#region src/collection/core/promptSafety.ts
+/** Max chars kept — the first batch of a validation issue is enough to act on. */
+var DEFANG_MAX_LEN = 200;
+function defangForPrompt(value) {
+	return value.replace(/[<>]/g, "").replace(/`/g, "'").replace(/\$\{/g, "$ {").replace(/\s+/g, " ").slice(0, DEFANG_MAX_LEN);
+}
+//#endregion
+export { ENUM_ALERT, ENUM_NEUTRAL, ENUM_NUDGE, FEED_SCHEDULES, INGEST_KINDS, MINUTES_PER_DAY, TOOL_DEFINITION, TOOL_NAME, actionVisible, assignLanes, boolSortValue, bucketRecords, buildMonthGrid, buildUpdatedRecord, coerceInlineValue, compareSortValues, compareYmd, dateOf, dateSortValue, daySlice, defangForPrompt, deriveAll, draftToRecord, emptyRow, enumColorClasses, enumSortValue, enumValueIndex, errorMessage, evaluateDerived, executePresentCollection, fieldVisible, firstMissingRequiredField, isFieldDrivenEvery, isSortableField, itemIdOf, itemLabelOf, labelFieldFor, monthAnchorDate, nextSortDirection, numericSortValue, parseIsoDate, parseIsoDateTime, parseTimeRange, recordSpan, resolveEnumColor, resolveRowRefs, rowFromItem, shortHexId, sortItems, spanCoversDay, stringSortValue, whenMatches, ymdKey };
+
+//# sourceMappingURL=index.js.map