@mulmoclaude/core 1.6.0 → 1.7.0

package/assets/helps/google-calendar-collection.md

@@ -6,10 +6,22 @@ events on a schedule and writes them as records — **without calling you**. No
 tool call, no tokens spent per sync, so hourly syncing is free.
 
 This is the mechanism for *keeping a collection fresh*. For one-off reads and
-for creating / editing / deleting events, use the `google` tool — see
+for deleting events, use the `google` tool — see
 [The `google` tool](google.md). There is no bundled calendar collection: you
 author the schema when the user asks for one.
 
+## Both directions, but only one of them automatic
+
+| Direction | How | When it runs |
+| --- | --- | --- |
+| Google → collection | the `googleCalendar` block | hourly, on creation, and on the **Sync** button |
+| collection → Google | the **Push to Google** button in the collection view | only when the user clicks it |
+
+There is no automatic write-back and no setting that enables one. If a user
+asks for "two-way sync", tell them plainly: the pull is automatic, the push is
+a button they press. Do not go looking for a config key for it — there isn't
+one, and hunting for it is what makes this conversation go in circles.
+
 ## Requirements
 
 The user's Google account must be linked (`google` tool, `kind: "status"`). If
@@ -81,8 +93,50 @@ the calendar day view then draws each record as a proportional time block.
   records on that first pass.
 
 Records are ordinary collection records: the user can open, filter, and view
-them like any other. Edits they make locally are overwritten the next time
-Google reports a change to that event.
+them like any other.
+
+## Pushing local work back — the Push to Google button
+
+The collection view has a **Push to Google** button next to Sync. It creates
+events for records added locally and updates events for records edited locally.
+
+**Order matters, and this is the one thing to warn users about.** A pull
+overwrites a locally edited record as soon as Google reports any change to that
+event. So: push first, then sync. Syncing first can discard the edit that was
+waiting to be pushed.
+
+What the button does and deliberately does not do:
+
+- **Creates** an event for a record that never came from a sync.
+- **Updates** only the fields the user actually changed, so attendees,
+  reminders and recurrence rules stay untouched.
+- **Never deletes.** A record deleted locally leaves its Google event alone —
+  a Google delete removes the event for every attendee and cannot be undone.
+  The count is reported so the user knows it was skipped; deleting for real is
+  the `google` tool's `calendarDeleteEvent`, after confirming with them.
+- **Skips a record edited on both sides** and reports it, rather than picking a
+  winner. The user resolves it by editing one side to match.
+- Pushes only `summary`, `start`, `end` and `colorId` — `htmlLink` and `status`
+  are read-only in Google, so a column mapped to either is ignored.
+
+Reasons a record can be reported as skipped:
+
+- **Its record id cannot be a Google event id.** Google requires 5-1024
+  characters from `0-9a-v`. Records created through the UI get a valid
+  generated id; a semantic id you authored (`team-standup`) cannot be used. Fix
+  by recreating the record without setting the primary field.
+- **No `start` / `end` is mapped, on a record being CREATED.** An event cannot
+  be created without a span. Editing an existing event is unaffected — a changed
+  title or colour is patched on its own.
+- **The calendar reports no timezone**, and the stored clock carries no offset
+  to fall back on.
+- **Clearing an event colour** — Google has no way to unset one.
+
+If the user only has `reader` access to the calendar, the whole push is refused
+with that reason rather than failing event by event. A calendar the user can
+reach by id but has not added to their calendar list has no role to check, so
+the push goes ahead and reports Google's own refusal if the write turns out not
+to be allowed — being unlisted is not treated as being read-only.
 
 ## Not for this
 

package/assets/helps/google.md

@@ -15,10 +15,11 @@ the original call — do not fall back to guessing.
 | --- | --- |
 | Read or change specific events / tasks / files, right now | this tool |
 | A collection that mirrors a calendar and keeps itself fresh | a `googleCalendar` block — see [Google Calendar sync](google-calendar-collection.md) |
+| Records the user added/edited in a calendar collection to reach Google | the collection view's **Push to Google** button, not this tool |
 
 The collection route costs no tokens per refresh, so prefer it for anything
-recurring. Use this tool for one-off work and for everything the collection
-route cannot do (creating, editing and deleting).
+recurring. Use this tool for one-off work, and for deleting — the push button
+never deletes.
 
 ## Calendar
 

package/dist/calendarGrid-CaS9er8i.cjs

@@ -0,0 +1,576 @@
+//#region src/collection/core/fieldText.ts
+/** A field value that has a meaningful text form. Dates are included because
+*  a JSON record can carry one once it has been revived. */
+var isTextable = (value) => typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value instanceof Date;
+/** The field's text, or `null` when it has no meaningful one (absent, or an
+*  array/object that would stringify to `"[object Object]"`).
+*
+*  Returning `null` rather than `""` keeps "the field is empty" distinct from
+*  "the field can't be text" — a matcher must not treat an object-valued field
+*  as an empty string and match `""`. */
+function fieldTextOrNull(value) {
+	if (value === void 0 || value === null) return null;
+	if (!isTextable(value)) return null;
+	if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : value.toISOString();
+	return String(value);
+}
+/** The field's text, or `fallback` (default `""`) when it has none. Use where
+*  a string is required and an empty one is a safe stand-in — display, sort
+*  keys, CSV cells. Where the distinction matters, use {@link fieldTextOrNull}. */
+function fieldText(value, fallback = "") {
+	return fieldTextOrNull(value) ?? fallback;
+}
+//#endregion
+//#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/rollup/toggle/flag 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",
+	"rollup",
+	"toggle",
+	"flag"
+]);
+/** Narrowing guard: true when `every` is the field-driven arm. */
+function isFieldDrivenEvery(every) {
+	return "fromField" in every;
+}
+/** Which storage backend serves this schema's records. Derived, not stored:
+*  existing schemas carry no `storage` key and must keep resolving exactly
+*  as before (`dataSource` ⇒ csv, else file). */
+function storageKindFor(schema) {
+	if (schema.dataSource !== void 0) return "csv";
+	return schema.storage?.type ?? "file";
+}
+/** True when `schema` declares an external `dataSource` — i.e. the
+*  collection is READ-ONLY through every UI/tool write path (updates
+*  happen by editing/replacing the data file itself). Isomorphic: both
+*  the server write guards and the client's control hiding key off this
+*  one predicate. */
+function isReadOnlySchema(schema) {
+	return schema.dataSource !== void 0;
+}
+/** 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 fieldText(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("..");
+}
+var DEFAULT_UNIQUE_ID_ATTEMPTS = 8;
+/** Pick an id not already in `existing`, re-rolling `generate()` up to
+*  `maxAttempts` times before giving up and returning the last candidate.
+*  Collisions on a wide id space are astronomically unlikely, so a caller's
+*  own overwrite guard is the final backstop rather than an unbounded loop. */
+function generateUniqueId(existing, generate, maxAttempts = DEFAULT_UNIQUE_ID_ATTEMPTS) {
+	let candidate = generate();
+	for (let attempt = 0; attempt < maxAttempts && existing.has(candidate); attempt++) candidate = generate();
+	return candidate;
+}
+/** An id not already used by any loaded record: collects the in-memory primary
+*  keys and re-rolls `generate()` against them (see {@link generateUniqueId}).
+*  The pure core of the view's create-form id prefill. */
+function nextUniqueItemId(items, primaryKey, generate, maxAttempts = DEFAULT_UNIQUE_ID_ATTEMPTS) {
+	return generateUniqueId(new Set(items.map((item) => fieldText(item[primaryKey]))), generate, maxAttempts);
+}
+//#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, "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, "embedTargetId", {
+	enumerable: true,
+	get: function() {
+		return embedTargetId;
+	}
+});
+Object.defineProperty(exports, "fieldText", {
+	enumerable: true,
+	get: function() {
+		return fieldText;
+	}
+});
+Object.defineProperty(exports, "fieldTextOrNull", {
+	enumerable: true,
+	get: function() {
+		return fieldTextOrNull;
+	}
+});
+Object.defineProperty(exports, "generateUniqueId", {
+	enumerable: true,
+	get: function() {
+		return generateUniqueId;
+	}
+});
+Object.defineProperty(exports, "isFieldDrivenEvery", {
+	enumerable: true,
+	get: function() {
+		return isFieldDrivenEvery;
+	}
+});
+Object.defineProperty(exports, "isReadOnlySchema", {
+	enumerable: true,
+	get: function() {
+		return isReadOnlySchema;
+	}
+});
+Object.defineProperty(exports, "isSafeRecordId", {
+	enumerable: true,
+	get: function() {
+		return isSafeRecordId;
+	}
+});
+Object.defineProperty(exports, "isSafeSlug", {
+	enumerable: true,
+	get: function() {
+		return isSafeSlug;
+	}
+});
+Object.defineProperty(exports, "monthAnchorDate", {
+	enumerable: true,
+	get: function() {
+		return monthAnchorDate;
+	}
+});
+Object.defineProperty(exports, "nextUniqueItemId", {
+	enumerable: true,
+	get: function() {
+		return nextUniqueItemId;
+	}
+});
+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, "spanCoversDay", {
+	enumerable: true,
+	get: function() {
+		return spanCoversDay;
+	}
+});
+Object.defineProperty(exports, "storageKindFor", {
+	enumerable: true,
+	get: function() {
+		return storageKindFor;
+	}
+});
+Object.defineProperty(exports, "ymdKey", {
+	enumerable: true,
+	get: function() {
+		return ymdKey;
+	}
+});
+
+//# sourceMappingURL=calendarGrid-CaS9er8i.cjs.map