@mulmoclaude/core 0.13.1 → 0.15.0

package/dist/calendarGrid-gN4sei7s.cjs

@@ -0,0 +1,1070 @@
+//#region src/collection/core/schema.ts
+/** Declarative retriever kinds a Feed's `ingest.kind` may declare. The host's
+*  feeds engine dispatches on these; they live here (with the schema contract)
+*  so the schema validator can enforce them. The host re-exports these from
+*  `server/workspace/feeds/ingestTypes.ts`. */
+var INGEST_KINDS = [
+	"rss",
+	"atom",
+	"http-json"
+];
+/** The agent-performed ingest kind. Instead of a declarative fetch, the host
+*  dispatches a hidden background chat (origin `system`) in `ingest.role`,
+*  seeded with `ingest.template` + a summary of every record, on the
+*  `ingest.schedule` cadence; the worker edits records via the collections io
+*  layer. Kept separate from {@link INGEST_KINDS} (which the declarative
+*  retriever registry keys on) so the schema validator can model `ingest` as a
+*  discriminated union without the feeds engine gaining an "agent" retriever. */
+var AGENT_INGEST_KIND = "agent";
+/** Refresh cadences a Feed's `ingest.schedule` may declare. */
+var FEED_SCHEDULES = [
+	"hourly",
+	"daily",
+	"weekly",
+	"on-demand"
+];
+/** derived/embed/backlinks/toggle are host-computed or projected — never
+*  written to the record JSON, so required / value checks and edit-draft
+*  slots must not apply to them. THE single source for "computed" —
+*  lives here (zod-free at runtime) so browser code (`./draft`) and the
+*  zod record compiler (`./recordZ`, which re-exports it) share one set
+*  instead of drifting copies. */
+var COMPUTED_TYPES = /* @__PURE__ */ new Set([
+	"derived",
+	"embed",
+	"backlinks",
+	"toggle"
+]);
+/** Narrowing guard: true when `every` is the field-driven arm. */
+function isFieldDrivenEvery(every) {
+	return "fromField" in every;
+}
+/** Resolve an `embed` field's target record id: the fixed `id`, or the value
+*  of the sibling `idField` on this record (empty string when neither applies
+*  — the caller renders that as "no record"). Pure + isomorphic so the server
+*  projection (`derive.ts`) and the client preview (`useCollectionRendering`)
+*  resolve embeds identically. Non-`embed` fields resolve to "no record". */
+function embedTargetId(field, record) {
+	if (field.type !== "embed") return "";
+	if (field.id) return field.id;
+	if (field.idField && record) return String(record[field.idField] ?? "");
+	return "";
+}
+//#endregion
+//#region src/collection/core/ids.ts
+var SAFE_SLUG_PATTERN = /^[a-zA-Z0-9](?:[a-zA-Z0-9_-]*[a-zA-Z0-9])?$/;
+var SAFE_RECORD_ID_PATTERN = /^[a-zA-Z0-9](?:[a-zA-Z0-9_.-]*[a-zA-Z0-9])?$/;
+/** True when `value` is a well-formed collection slug (alphanumeric /
+*  hyphen / underscore, no path separators). The pattern admits no `/`,
+*  `\`, or `.`, so a passing value is trivially also a safe basename —
+*  validation callers need no `path.basename` round-trip (path-building
+*  callers use `../server/paths#safeSlugName`, which adds it). */
+function isSafeSlug(value) {
+	return typeof value === "string" && SAFE_SLUG_PATTERN.test(value);
+}
+/** True when `value` is a well-formed record id (slug charset plus interior
+*  dots), with any `..` substring rejected explicitly. Validation-only
+*  counterpart of `../server/paths#safeRecordId`. */
+function isSafeRecordId(value) {
+	if (typeof value !== "string" || !SAFE_RECORD_ID_PATTERN.test(value)) return false;
+	return !value.includes("..");
+}
+//#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/backlinks.ts
+/** The SOURCE records whose `via` field stores `recordId` (compared as
+*  strings, like every ref deref), with the optional `filter` applied —
+*  in the source items' given order. Fail-soft by construction: a `via`
+*  key that doesn't exist on the source records simply matches nothing.
+*  Callers pass DERIVED source records, so a `filter`/`display` on a
+*  derived column works when its formula is SELF-CONTAINED (an invoice
+*  `total` = sum over its own line items); a source column that derefs
+*  yet another collection stays absent — the same each-record-derives-
+*  against-itself rule ref targets follow. */
+function backlinkRows(spec, recordId, sourceItems) {
+	if (!recordId) return [];
+	return sourceItems.filter((item) => String(item[spec.via] ?? "") === recordId && whenMatches(spec.filter, item));
+}
+/** Project one backlink row to the keys consumers surface: the source
+*  collection's primaryKey (rows must stay addressable — it's the link
+*  target) plus the declared `display` columns. Keys the row doesn't
+*  carry are simply absent, mirroring `projectFields` in getItems. */
+function projectBacklinkRow(row, display, primaryKey) {
+	const keys = display.includes(primaryKey) ? display : [primaryKey, ...display];
+	return Object.fromEntries(keys.filter((key) => key in row).map((key) => [key, row[key]]));
+}
+//#endregion
+//#region src/collection/core/where.ts
+/** True when `record[field]` is absent (`undefined`/`null`) — the only case
+*  where `ne` and every other op disagree on the result. */
+function isMissing(raw) {
+	return raw === void 0 || raw === null;
+}
+/** The effective comparison value for `cond`: its literal `value`, or — for
+*  a `valueFrom` reference — the target field read out of `recordsById`.
+*  `undefined` means UNRESOLVED (no such record, or the field on it is
+*  missing); the caller must treat that as "never matches", not as a
+*  literal `undefined` value to compare against. */
+function resolveValue(cond, record, recordsById) {
+	if (!cond.valueFrom) return cond.value;
+	const { record: refRecord, field } = cond.valueFrom;
+	const raw = (refRecord === void 0 ? record : recordsById[refRecord])?.[field];
+	return isMissing(raw) ? void 0 : String(raw);
+}
+function matchesNumericOp(operator, left, right) {
+	if (operator === "gt") return left > right;
+	if (operator === "gte") return left >= right;
+	if (operator === "lt") return left < right;
+	return left <= right;
+}
+/** `Number("")` / `Number("  ")` are `0`, not `NaN`, so treat a blank string
+*  as non-numeric explicitly — an empty field must fail a numeric compare,
+*  not read as zero. */
+function toNumber(raw) {
+	return raw.trim() === "" ? NaN : Number(raw);
+}
+function matchesNumeric(operator, raw, value) {
+	if (Array.isArray(value)) return false;
+	const left = toNumber(raw);
+	const right = toNumber(value);
+	if (Number.isNaN(left) || Number.isNaN(right)) return false;
+	return matchesNumericOp(operator, left, right);
+}
+/** True when the present string `raw` satisfies `operator` against the
+*  resolved `value` (field known to exist — MISSING is handled by the
+*  caller before this runs, and an UNRESOLVED `valueFrom` never reaches
+*  here either). */
+function matchesPresent(operator, raw, value) {
+	switch (operator) {
+		case "eq": return raw === String(value);
+		case "ne": return raw !== String(value);
+		case "in": return Array.isArray(value) && value.includes(raw);
+		case "contains": return raw.includes(String(value));
+		case "gt":
+		case "gte":
+		case "lt":
+		case "lte": return matchesNumeric(operator, raw, value);
+		default: return false;
+	}
+}
+/** True when `record` satisfies one condition, given `recordsById` to
+*  resolve a `valueFrom` reference. Two independent MISSING cases, checked
+*  in order:
+*  - `record[cond.field]` absent (`undefined`/`null`) → matches only `ne`
+*    (vacuously true — "not equal to X" holds when there's no value at
+*    all); every other op is false. Unchanged from the literal-`value`
+*    behaviour, regardless of whether `valueFrom` would also resolve.
+*  - the resolved comparison value is UNRESOLVED (a `valueFrom` whose
+*    target record/field doesn't exist) → false for EVERY op, including
+*    `ne` — a broken reference must never spuriously match. */
+function matchesCond(cond, record, recordsById) {
+	const raw = record[cond.field];
+	if (isMissing(raw)) return cond.op === "ne";
+	const value = resolveValue(cond, record, recordsById);
+	if (value === void 0) return false;
+	return matchesPresent(cond.op, String(raw), value);
+}
+/** True when `record` satisfies every condition in `where` (AND). An empty
+*  `where` matches everything. `recordsById` — the source collection's
+*  records keyed by primaryKey — resolves any `valueFrom` reference;
+*  omitted (default `{}`) for callers with no cross-record lookups, in
+*  which case every `valueFrom` condition is UNRESOLVED and so never
+*  matches. */
+function matchesWhere(where, record, recordsById = {}) {
+	return where.every((cond) => matchesCond(cond, record, recordsById));
+}
+//#endregion
+//#region src/collection/core/dynamicIcon.ts
+/** The record with the greatest `String(record[field])` (localeCompare) —
+*  ties keep the first-seen record (stable left-to-right `reduce`). */
+function latestByField(pool, field) {
+	return pool.reduce((latest, candidate) => String(candidate[field] ?? "").localeCompare(String(latest[field] ?? "")) > 0 ? candidate : latest);
+}
+/** Reduce `records` to the one record that decides the effective icon, per
+*  `source`'s `where` filter + `from` strategy:
+*  - pool = `source.where`-filtered records, or every record when unset;
+*  - an empty pool resolves to `null` (no source record → fallback);
+*  - `from: "first"` / `"when"` → the first pool record (storage order);
+*  - `from: "latest"` (default), with `orderBy` given → the pool record
+*    whose `String(record[orderBy])` sorts highest;
+*  - `from: "latest"`, with no `orderBy` → the last pool record.
+*  `recordsById` (the source collection's records keyed by primaryKey)
+*  resolves any `valueFrom` reference inside `source.where`; omitted for
+*  callers with no cross-record lookups. */
+function selectDynamicRecord(records, source, orderBy, recordsById = {}) {
+	const { where } = source;
+	const pool = where ? records.filter((record) => matchesWhere(where, record, recordsById)) : records;
+	if (pool.length === 0) return null;
+	if (source.from === "first" || source.from === "when") return pool[0];
+	return orderBy ? latestByField(pool, orderBy) : pool[pool.length - 1];
+}
+/** Map a resolved source record to the effective icon: `spec.fallback`
+*  (or the collection's own static `icon`) when there's no record or no
+*  rule matches; otherwise the `icon` of the first rule whose `where`
+*  matches the record. `recordsById` resolves any `valueFrom` reference
+*  inside a rule's `where`, same as `selectDynamicRecord`. */
+function resolveIcon(record, spec, staticIcon, recordsById = {}) {
+	const fallback = spec.fallback ?? staticIcon;
+	if (!record) return fallback;
+	const matched = spec.rules.find((rule) => matchesWhere(rule.where, record, recordsById));
+	return matched ? matched.icon : fallback;
+}
+var isDateLikeField = (field) => field.type === "date" || field.type === "datetime";
+/** The first field key (declaration order) whose type is `date` or
+*  `datetime` — the default `orderBy` for `from: "latest"` when a
+*  `DynamicIconSource` doesn't name one. `undefined` when the schema has
+*  no date-like field. */
+function firstDateField(schema) {
+	return Object.entries(schema.fields).find(([, field]) => isDateLikeField(field))?.[0];
+}
+//#endregion
+//#region src/collection/core/derivedFormula.ts
+function evaluateDerived(formula, ctx) {
+	let tokens;
+	try {
+		tokens = tokenize(formula);
+	} catch {
+		return null;
+	}
+	const parser = new Parser(tokens);
+	let ast;
+	try {
+		ast = parser.parseExpr();
+		if (!parser.atEnd()) return null;
+	} catch {
+		return null;
+	}
+	const value = evaluate(ast, ctx);
+	return Number.isFinite(value) ? value : null;
+}
+var SINGLE_CHAR_PUNCT = /* @__PURE__ */ new Set([
+	"(",
+	")",
+	"+",
+	"-",
+	"*",
+	"/",
+	"."
+]);
+function consumeWhitespace(cur) {
+	const char = cur.input[cur.index];
+	if (char === " " || char === "	" || char === "\n") {
+		cur.index++;
+		return true;
+	}
+	return false;
+}
+function consumeNumber(cur) {
+	const char = cur.input[cur.index] ?? "";
+	const next = cur.input[cur.index + 1] ?? "";
+	if (!isDigit(char) && !(char === "." && isDigit(next))) return null;
+	let raw = "";
+	while (cur.index < cur.input.length) {
+		const here = cur.input[cur.index] ?? "";
+		if (!isDigit(here) && here !== ".") break;
+		raw += here;
+		cur.index++;
+	}
+	const num = Number(raw);
+	if (!Number.isFinite(num)) throw new Error("bad number");
+	return {
+		kind: "number",
+		value: num
+	};
+}
+function consumeIdent(cur) {
+	if (!isIdentStart(cur.input[cur.index] ?? "")) return null;
+	let raw = "";
+	while (cur.index < cur.input.length && isIdentChar(cur.input[cur.index] ?? "")) {
+		raw += cur.input[cur.index];
+		cur.index++;
+	}
+	return {
+		kind: "ident",
+		value: raw
+	};
+}
+function consumePunct(cur) {
+	const char = cur.input[cur.index] ?? "";
+	if (char === "[" && cur.input[cur.index + 1] === "]") {
+		cur.index += 2;
+		return { kind: "[]" };
+	}
+	if (SINGLE_CHAR_PUNCT.has(char)) {
+		cur.index++;
+		return { kind: char };
+	}
+	return null;
+}
+function tokenize(input) {
+	const tokens = [];
+	const cur = {
+		input,
+		index: 0
+	};
+	while (cur.index < input.length) {
+		if (consumeWhitespace(cur)) continue;
+		const numTok = consumeNumber(cur);
+		if (numTok) {
+			tokens.push(numTok);
+			continue;
+		}
+		const punctTok = consumePunct(cur);
+		if (punctTok) {
+			tokens.push(punctTok);
+			continue;
+		}
+		const identTok = consumeIdent(cur);
+		if (identTok) {
+			tokens.push(identTok);
+			continue;
+		}
+		throw new Error(`unexpected char ${input[cur.index]}`);
+	}
+	return tokens;
+}
+function isDigit(char) {
+	return char >= "0" && char <= "9";
+}
+function isIdentStart(char) {
+	return char >= "a" && char <= "z" || char >= "A" && char <= "Z" || char === "_";
+}
+function isIdentChar(char) {
+	return isIdentStart(char) || isDigit(char);
+}
+var Parser = class {
+	tokens;
+	cursor = 0;
+	constructor(tokens) {
+		this.tokens = tokens;
+	}
+	atEnd() {
+		return this.cursor >= this.tokens.length;
+	}
+	peek() {
+		return this.tokens[this.cursor];
+	}
+	consume() {
+		const tok = this.tokens[this.cursor++];
+		if (!tok) throw new Error("unexpected end of input");
+		return tok;
+	}
+	expect(kind) {
+		const tok = this.consume();
+		if (tok.kind !== kind) throw new Error(`expected ${kind}, got ${tok.kind}`);
+		return tok;
+	}
+	parseExpr() {
+		let left = this.parseTerm();
+		while (this.peek()?.kind === "+" || this.peek()?.kind === "-") {
+			const operator = this.consume().kind;
+			const right = this.parseTerm();
+			left = {
+				kind: "binop",
+				operator,
+				left,
+				right
+			};
+		}
+		return left;
+	}
+	parseTerm() {
+		let left = this.parseFactor();
+		while (this.peek()?.kind === "*" || this.peek()?.kind === "/") {
+			const operator = this.consume().kind;
+			const right = this.parseFactor();
+			left = {
+				kind: "binop",
+				operator,
+				left,
+				right
+			};
+		}
+		return left;
+	}
+	parseFactor() {
+		const tok = this.peek();
+		if (!tok) throw new Error("unexpected end in factor");
+		if (tok.kind === "number") {
+			this.consume();
+			return {
+				kind: "num",
+				value: tok.value
+			};
+		}
+		if (tok.kind === "(") {
+			this.consume();
+			const inner = this.parseExpr();
+			this.expect(")");
+			return inner;
+		}
+		if (tok.kind === "ident") {
+			const name = tok.value ?? "";
+			if (name === "sum" && this.tokens[this.cursor + 1]?.kind === "(") {
+				this.consume();
+				this.expect("(");
+				const arg = this.parseSumArg();
+				this.expect(")");
+				return {
+					kind: "sum",
+					arg
+				};
+			}
+			this.consume();
+			if (this.peek()?.kind === ".") {
+				this.consume();
+				return {
+					kind: "ref",
+					field: name,
+					col: this.expect("ident").value
+				};
+			}
+			return {
+				kind: "ident",
+				name
+			};
+		}
+		throw new Error(`unexpected token ${tok.kind} in factor`);
+	}
+	parseSumArg() {
+		const factors = [];
+		const operators = [];
+		factors.push(this.parseTableCol());
+		while (this.peek()?.kind === "*" || this.peek()?.kind === "/") {
+			const operator = this.consume().kind;
+			operators.push(operator);
+			factors.push(this.parseTableCol());
+		}
+		return {
+			factors,
+			operators
+		};
+	}
+	parseTableCol() {
+		const tableTok = this.expect("ident");
+		this.expect("[]");
+		this.expect(".");
+		const colTok = this.expect("ident");
+		return {
+			table: tableTok.value,
+			col: colTok.value
+		};
+	}
+};
+function evaluate(node, ctx) {
+	if (node.kind === "num") return node.value;
+	if (node.kind === "ident") {
+		const raw = ctx.record[node.name];
+		return toFiniteNumber(raw);
+	}
+	if (node.kind === "ref") {
+		const target = ctx.refs?.[node.field] ?? null;
+		if (!target) return NaN;
+		return toFiniteNumber(target[node.col]);
+	}
+	if (node.kind === "binop") {
+		const left = evaluate(node.left, ctx);
+		const right = evaluate(node.right, ctx);
+		return applyBinop(node.operator, left, right);
+	}
+	if (node.kind === "sum") return evaluateSum(node.arg, ctx);
+	throw new Error(`unknown node`);
+}
+function applyBinop(operator, left, right) {
+	if (!Number.isFinite(left) || !Number.isFinite(right)) return NaN;
+	if (operator === "+") return left + right;
+	if (operator === "-") return left - right;
+	if (operator === "*") return left * right;
+	if (right === 0) return NaN;
+	return left / right;
+}
+function evaluateSum(arg, ctx) {
+	if (arg.factors.length === 0) return 0;
+	const tableName = arg.factors[0].table;
+	for (const factor of arg.factors) if (factor.table !== tableName) return NaN;
+	const rows = ctx.record[tableName];
+	if (!Array.isArray(rows)) return 0;
+	let total = 0;
+	for (const row of rows) {
+		if (!row || typeof row !== "object") continue;
+		let product = toFiniteNumber(row[arg.factors[0].col]);
+		if (!Number.isFinite(product)) return NaN;
+		for (let i = 1; i < arg.factors.length; i++) {
+			const value = toFiniteNumber(row[arg.factors[i].col]);
+			if (!Number.isFinite(value)) return NaN;
+			product = applyBinop(arg.operators[i - 1], product, value);
+		}
+		total += product;
+	}
+	return total;
+}
+function toFiniteNumber(value) {
+	if (typeof value === "number") return Number.isFinite(value) ? value : NaN;
+	if (typeof value === "string" && value.length > 0) {
+		const num = Number(value);
+		return Number.isFinite(num) ? num : NaN;
+	}
+	return NaN;
+}
+//#endregion
+//#region src/collection/core/deriveAll.ts
+/** Map each `ref` field's stored slug to its loaded target record (or
+*  null when dangling / not loaded), keyed by the LOCAL field name —
+*  the shape `evaluateDerived` reads for `<field>.<col>` derefs. */
+function resolveRowRefs(schema, record, refRecords) {
+	const refs = {};
+	for (const [key, field] of Object.entries(schema.fields)) {
+		if (field.type !== "ref" || !field.to) continue;
+		const slug = record[key];
+		refs[key] = typeof slug === "string" ? refRecords[field.to]?.[slug] ?? null : null;
+	}
+	return refs;
+}
+/** Evaluate every `derived` field against `base`, saturating so a
+*  derived field can read another derived field computed in an earlier
+*  pass (`subtotal → tax → total` converges in ≤ field-count passes).
+*  Cycles can't loop forever — passes are bounded by the number of
+*  derived fields and the loop breaks as soon as a pass changes
+*  nothing. Failed formulas stay ABSENT (the UI renders them as
+*  em-dash). Returns a copy; `base` is never mutated.
+*
+*  Derived keys already present in `base` are stripped before
+*  evaluation: computed output is host-truth, never persisted-input
+*  fallback. A record JSON can carry a stale (or forged) derived value
+*  — raw Write/Edit, legacy data — and without the strip, a failing
+*  formula would silently surface that value as if the host computed
+*  it. */
+function deriveAll(schema, base, refRecords) {
+	const derivedKeys = new Set(Object.keys(schema.fields).filter((key) => schema.fields[key]?.type === "derived"));
+	const enriched = Object.fromEntries(Object.entries(base).filter(([key]) => !derivedKeys.has(key)));
+	const refs = resolveRowRefs(schema, base, refRecords);
+	const maxPasses = Object.values(schema.fields).filter((field) => field.type === "derived").length;
+	for (let pass = 0; pass < maxPasses; pass++) {
+		let mutated = false;
+		for (const [key, field] of Object.entries(schema.fields)) {
+			if (field.type !== "derived" || !field.formula) continue;
+			const next = evaluateDerived(field.formula, {
+				record: enriched,
+				refs
+			});
+			if (next !== null && enriched[key] !== next) {
+				enriched[key] = next;
+				mutated = true;
+			}
+		}
+		if (!mutated) break;
+	}
+	return enriched;
+}
+//#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
+Object.defineProperty(exports, "AGENT_INGEST_KIND", {
+	enumerable: true,
+	get: function() {
+		return AGENT_INGEST_KIND;
+	}
+});
+Object.defineProperty(exports, "COMPUTED_TYPES", {
+	enumerable: true,
+	get: function() {
+		return COMPUTED_TYPES;
+	}
+});
+Object.defineProperty(exports, "FEED_SCHEDULES", {
+	enumerable: true,
+	get: function() {
+		return FEED_SCHEDULES;
+	}
+});
+Object.defineProperty(exports, "INGEST_KINDS", {
+	enumerable: true,
+	get: function() {
+		return INGEST_KINDS;
+	}
+});
+Object.defineProperty(exports, "MINUTES_PER_DAY", {
+	enumerable: true,
+	get: function() {
+		return MINUTES_PER_DAY;
+	}
+});
+Object.defineProperty(exports, "SAFE_RECORD_ID_PATTERN", {
+	enumerable: true,
+	get: function() {
+		return SAFE_RECORD_ID_PATTERN;
+	}
+});
+Object.defineProperty(exports, "SAFE_SLUG_PATTERN", {
+	enumerable: true,
+	get: function() {
+		return SAFE_SLUG_PATTERN;
+	}
+});
+Object.defineProperty(exports, "actionVisible", {
+	enumerable: true,
+	get: function() {
+		return actionVisible;
+	}
+});
+Object.defineProperty(exports, "assignLanes", {
+	enumerable: true,
+	get: function() {
+		return assignLanes;
+	}
+});
+Object.defineProperty(exports, "backlinkRows", {
+	enumerable: true,
+	get: function() {
+		return backlinkRows;
+	}
+});
+Object.defineProperty(exports, "bucketRecords", {
+	enumerable: true,
+	get: function() {
+		return bucketRecords;
+	}
+});
+Object.defineProperty(exports, "buildMonthGrid", {
+	enumerable: true,
+	get: function() {
+		return buildMonthGrid;
+	}
+});
+Object.defineProperty(exports, "compareYmd", {
+	enumerable: true,
+	get: function() {
+		return compareYmd;
+	}
+});
+Object.defineProperty(exports, "dateOf", {
+	enumerable: true,
+	get: function() {
+		return dateOf;
+	}
+});
+Object.defineProperty(exports, "daySlice", {
+	enumerable: true,
+	get: function() {
+		return daySlice;
+	}
+});
+Object.defineProperty(exports, "deriveAll", {
+	enumerable: true,
+	get: function() {
+		return deriveAll;
+	}
+});
+Object.defineProperty(exports, "embedTargetId", {
+	enumerable: true,
+	get: function() {
+		return embedTargetId;
+	}
+});
+Object.defineProperty(exports, "evaluateDerived", {
+	enumerable: true,
+	get: function() {
+		return evaluateDerived;
+	}
+});
+Object.defineProperty(exports, "fieldVisible", {
+	enumerable: true,
+	get: function() {
+		return fieldVisible;
+	}
+});
+Object.defineProperty(exports, "firstDateField", {
+	enumerable: true,
+	get: function() {
+		return firstDateField;
+	}
+});
+Object.defineProperty(exports, "isFieldDrivenEvery", {
+	enumerable: true,
+	get: function() {
+		return isFieldDrivenEvery;
+	}
+});
+Object.defineProperty(exports, "isSafeRecordId", {
+	enumerable: true,
+	get: function() {
+		return isSafeRecordId;
+	}
+});
+Object.defineProperty(exports, "isSafeSlug", {
+	enumerable: true,
+	get: function() {
+		return isSafeSlug;
+	}
+});
+Object.defineProperty(exports, "matchesWhere", {
+	enumerable: true,
+	get: function() {
+		return matchesWhere;
+	}
+});
+Object.defineProperty(exports, "monthAnchorDate", {
+	enumerable: true,
+	get: function() {
+		return monthAnchorDate;
+	}
+});
+Object.defineProperty(exports, "parseIsoDate", {
+	enumerable: true,
+	get: function() {
+		return parseIsoDate;
+	}
+});
+Object.defineProperty(exports, "parseIsoDateTime", {
+	enumerable: true,
+	get: function() {
+		return parseIsoDateTime;
+	}
+});
+Object.defineProperty(exports, "parseTimeRange", {
+	enumerable: true,
+	get: function() {
+		return parseTimeRange;
+	}
+});
+Object.defineProperty(exports, "projectBacklinkRow", {
+	enumerable: true,
+	get: function() {
+		return projectBacklinkRow;
+	}
+});
+Object.defineProperty(exports, "recordSpan", {
+	enumerable: true,
+	get: function() {
+		return recordSpan;
+	}
+});
+Object.defineProperty(exports, "resolveIcon", {
+	enumerable: true,
+	get: function() {
+		return resolveIcon;
+	}
+});
+Object.defineProperty(exports, "resolveRowRefs", {
+	enumerable: true,
+	get: function() {
+		return resolveRowRefs;
+	}
+});
+Object.defineProperty(exports, "selectDynamicRecord", {
+	enumerable: true,
+	get: function() {
+		return selectDynamicRecord;
+	}
+});
+Object.defineProperty(exports, "spanCoversDay", {
+	enumerable: true,
+	get: function() {
+		return spanCoversDay;
+	}
+});
+Object.defineProperty(exports, "whenMatches", {
+	enumerable: true,
+	get: function() {
+		return whenMatches;
+	}
+});
+Object.defineProperty(exports, "ymdKey", {
+	enumerable: true,
+	get: function() {
+		return ymdKey;
+	}
+});
+
+//# sourceMappingURL=calendarGrid-gN4sei7s.cjs.map