@mulmoclaude/core 0.13.1 → 0.14.0

package/assets/helps/billing-clients-worklog.md

@@ -103,18 +103,19 @@ Don't push for fields the user hasn't given you — leave optional fields out of
 the JSON entirely.
 
 ## What to do
-**Add**: derive an `id`, build the record, Write `data/clients/items/<id>.json`.
-List the directory first and pick a fresh slug if the file already exists — don't
-silently overwrite.
+**Add**: derive an `id`, build the record, write via `manageCollection`
+`putItems` with `mode: "create"` — an id collision comes back as a `rejected`
+row instead of silently overwriting; pick a fresh slug and retry.
 
-**List / look up**: read `data/clients/items/`, answer from those files. Don't
+**List / look up**: `manageCollection` `getItems`, answer from the rows. Don't
 recite the whole table in chat — the user sees it at `/collections/clients`. A
 one-line confirmation ("Added Acme Corp.") is enough.
 
-**Update**: Read → merge changes → Write back. Preserve fields you weren't asked
-to change.
+**Update**: `putItems` with `mode: "merge"` and a partial row
+(`{ id, <changed fields> }`) — the default upsert replaces the whole record.
 
-**Delete**: confirm once if the request is ambiguous, then remove the file.
+**Delete**: confirm once if the request is ambiguous, then remove the file
+(`manageCollection` has no delete).
 
 ## Linking to a client in chat
 Link to the collection view, not the raw JSON path:
@@ -179,18 +180,20 @@ description: A simple timesheet — log billable / non-billable hours per client
 ## clientId resolution
 `clientId` is a `ref` to the `clients` collection — write the raw client slug.
 When the user says "log 2 hours for Acme":
-- List `data/clients/items/` and find the slug whose `name` matches "Acme"
-  (case-insensitive substring is fine).
+- `manageCollection` `getItems` on `clients` (`fields: ["id", "name"]`) and
+  find the slug whose `name` matches "Acme" (case-insensitive substring is
+  fine).
 - If no match: ask whether to create the client first (via the `clients` skill)
   or use a literal slug they supply. Never invent a clientId that doesn't exist —
   it renders as a broken link.
 
 ## What to do
 **Log hours**: derive `id`, default `billable: true`, default `date` to today if
-unspecified, Write the JSON. (This skill tracks total hours per day per client —
-not start/end times.)
+unspecified, write via `manageCollection` `putItems` (`mode: "create"`; fix any
+`rejected` row from its `problem` text and retry). (This skill tracks total
+hours per day per client — not start/end times.)
 
-**List / summarize**: read `data/worklog/items/`, answer from the files. Don't
+**List / summarize**: `manageCollection` `getItems`, answer from the rows. Don't
 recite the table — point at `/collections/worklog`. For aggregates ("how many
 hours did I bill Acme last month?") group by clientId + date range and answer in
 one line.

package/assets/helps/collection-skills.md

@@ -31,7 +31,7 @@ data/skills/<slug>/            ← YOU write here (Write / Edit)
   SKILL.md  ·  schema.json  ·  templates/*.md
 
 data/<name>/items/             ← the records (separate from the skill dir)
-  <id>.json         ← one record per file (you write; host reads + renders)
+  <id>.json         ← one record per file (write via manageCollection putItems)
 ```
 
 - **Author under `data/skills/<slug>/`, NEVER `.claude/skills/<slug>/`
@@ -761,10 +761,25 @@ single source of truth and the "done" checkbox is a `toggle` field projecting it
 
 ## Records — one JSON object per file
 
-- Write each record to `<dataPath>/<id>.json` via the **Write** tool; the `id`
-  field's value is the filename (no extension).
+Each record is a plain file at `<dataPath>/<id>.json` (the `id` field's value is
+the filename, no extension) — that is the storage model. But you read and write
+records through **`manageCollection`**, not raw file I/O:
+
+- **Create / update — `putItems`.** Every row is validated against the schema
+  BEFORE the write (required fields, enum membership, primaryKey = record id)
+  and the result reports `{ written, rejected }` — fix each rejected row from
+  its `problem` text and retry just those rows. Use `mode: "create"` when
+  adding, so an id collision is rejected instead of silently overwritten, and
+  `mode: "merge"` with a partial row (`{ id, <changed fields> }`) when
+  updating — the default upsert replaces the WHOLE record and would erase
+  every optional field the row omits.
+- **Read / list — `getItems`.** The only way to see host-computed `derived` /
+  `toggle` / `embed` values (the stored JSON never contains them). Pass `ids`
+  / `fields` on large collections to keep the result small — e.g.
+  `fields: ["id"]` to check for an id collision before an add.
+- **Delete** — remove the record file (`manageCollection` has no delete).
 - **Id charset** (enforced by `safeRecordId` in
-  `packages/plugins/collection-plugin/src/server/paths.ts` — the single source of
+  `packages/core/src/collection/server/paths.ts` — the single source of
   truth; `manageCollection` rejects ids that fail it): start and end with a
   letter or digit; inside, also `-`, `_`, and `.` are allowed (so natural keys
   like a Slack ts `1718900000.123456` or a SemVer `1.2.3` work). **No** path
@@ -774,6 +789,24 @@ single source of truth and the "done" checkbox is a `toggle` field projecting it
   enforces this on every targeted read/write, so an id that only _looks_ fine in
   a full `getItems` listing but violates the rule can't be updated or deleted by
   id — fix the id, don't work around it with raw file I/O.
+- **Never write `derived` fields**, and never write an `embed` field — both are
+  display-only / host-computed (`putItems` rejects rows that carry them).
+- Leave optional fields out of the row entirely rather than writing empty
+  strings.
+- For a `ref` field, write the raw target slug, and make sure that record
+  actually exists in the target collection — an invalid slug renders as a broken
+  link. The host enforces structure and safety; **you own semantic correctness**
+  (valid refs, sane values).
+
+### Raw file I/O on records — the escape hatch
+
+Read / Write / Edit on the record files stays available (files are the source
+of truth), but it skips `putItems`' pre-write validation — a mistake lands on
+disk instead of coming back as a `rejected` row. Reach for it only when the
+tool can't do the job: bulk file surgery, or repairing a file so malformed
+that `manageCollection` can't address it. If you do write record files
+directly:
+
 - **The file MUST be valid JSON.** A malformed record is **silently skipped** at
   read time (logged server-side, but invisible in the UI) — so one bad file out
   of fifteen looks like "fourteen records vanished." The #1 cause is an
@@ -782,22 +815,12 @@ single source of truth and the "done" checkbox is a `toggle` field projecting it
   (`text`, `markdown`, a long `objective`), either escape every inner ASCII quote
   as `\"`, or — better — use the language's own quotation marks (`「」`/`『』` for
   Japanese, `‘ ’`/`“ ”` or `'…'` for English) so no escaping is needed.
-  `presentCollection` re-validates the records and reports any unreadable /
+- `presentCollection` re-validates the records and reports any unreadable /
   malformed / schema-violating files back to you (a `⚠️` in its result) — so
-  always follow a batch of writes with a `presentCollection` call and **act on
-  any ⚠️ it returns** (Read → fix → Write), rather than assuming every record
-  landed.
-- **List the directory first** and pick a fresh id rather than silently
-  overwriting. Update = Read, merge, Write back (preserve fields you weren't
-  asked to change). Delete = remove the file.
-- **Never write `derived` fields**, and never write an `embed` field — both are
-  display-only / host-computed.
-- Leave optional fields out of the JSON entirely rather than writing empty
-  strings.
-- For a `ref` field, write the raw target slug, and make sure that record
-  actually exists in the target collection — an invalid slug renders as a broken
-  link. The host enforces structure and safety; **you own semantic correctness**
-  (valid refs, sane values).
+  always follow a batch of direct writes with a `presentCollection` call and
+  **act on any ⚠️ it returns**, rather than assuming every record landed.
+  (This safety net applies after `putItems` batches too, but direct writes are
+  where it earns its keep.)
 
 ## End-to-end: creating a new collection skill
 

package/assets/helps/todo-collection.md

@@ -80,11 +80,16 @@ description: The user's personal todo list. Use whenever they add, list, edit,
 - Do NOT write a `done` field — it's a projection of `status`.
 
 ## What to do
-- **Add**: derive an id, default `status: "todo"`, Write the JSON.
-- **List**: read `data/todos/items/`, answer from the files; point the user at
-  `/collections/todos` rather than reciting the table.
-- **Mark done**: Read → set `status: "done"` → Write.
-- **Edit / Delete**: Read → mutate / remove the file (preserve untouched fields).
+- **Add**: derive an id, default `status: "todo"`, write via `manageCollection`
+  `putItems` (`mode: "create"`; a rejected row comes back with a `problem` to
+  fix and retry).
+- **List**: `manageCollection` `getItems` (the only way to see the computed
+  `done` toggle); point the user at `/collections/todos` rather than reciting
+  the table.
+- **Mark done**: `putItems` with `mode: "merge"` and `{ id, status: "done" }`.
+- **Edit**: `putItems` `mode: "merge"` with a partial row — the default upsert
+  replaces the whole record. **Delete**: remove the file (`manageCollection`
+  has no delete).
 - After a change, call `presentCollection` with slug `todos` (and the id) to show
   it inline.
 ```
@@ -131,8 +136,9 @@ single array) with the columns in the sibling `columns.json`. Convert them:
    the legacy list had.
 3. **Fold `completed` into `status`.** A legacy `completed: true` item belongs in
    the done column; don't carry a separate boolean.
-4. **One file per item.** Split the array into `data/todos/items/<id>.json`,
-   preserving each legacy `id` verbatim.
+4. **One record per item.** Split the array into one `putItems` row per item
+   (stored as `data/todos/items/<id>.json`), preserving each legacy `id`
+   verbatim.
 5. **Convert `createdAt`.** The legacy value is Unix milliseconds — convert it to
    a `YYYY-MM-DD` `date` field. Carry `priority`, `dueDate`, `note` straight
    across.

package/dist/{deriveAll-CMFXDQ_G.js → calendarGrid-C1rfCXJ3.cjs}

@@ -31,13 +31,33 @@ function isFieldDrivenEvery(every) {
 *  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. */
+*  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/where.ts
 /** True when `record[field]` is absent (`undefined`/`null`) — the only case
 *  where `ne` and every other op disagree on the result. */
@@ -501,6 +521,451 @@ function deriveAll(schema, base, refRecords) {
 	return enriched;
 }
 //#endregion
-export { resolveIcon as a, AGENT_INGEST_KIND as c, embedTargetId as d, isFieldDrivenEvery as f, firstDateField as i, FEED_SCHEDULES as l, resolveRowRefs as n, selectDynamicRecord as o, evaluateDerived as r, matchesWhere as s, deriveAll as t, INGEST_KINDS as u };
+//#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, "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, "assignLanes", {
+	enumerable: true,
+	get: function() {
+		return assignLanes;
+	}
+});
+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, "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, "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, "ymdKey", {
+	enumerable: true,
+	get: function() {
+		return ymdKey;
+	}
+});
 
-//# sourceMappingURL=deriveAll-CMFXDQ_G.js.map
+//# sourceMappingURL=calendarGrid-C1rfCXJ3.cjs.map