@mulmoclaude/core 0.23.1 → 0.25.0

package/assets/helps/collection-skills.md

@@ -132,8 +132,8 @@ skipped, never crashes the host):
 | `singleton`            | Optional. When set, at most one record exists, pinned to this exact id (e.g. `me`). Host pre-fills + locks the create form and hides Add once it exists.                                                                                                                                                                                                                                                                                                                                                                                                                           |
 | `fields`               | Ordered map of field-name → field spec. **Insertion order = column order** in the table. Required.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 | `actions`              | Optional array of per-record buttons (see below).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| `completionField`      | Optional. Name of the field whose value marks an item as "done" — when set, item-create fires a bell notification that clears once the field reaches one of `completionDoneValues`. Must name a real field in `fields`. Paired with `completionDoneValues` (both set, or both omitted).                                                                                                                                                                                                                                                                                            |
-| `completionDoneValues` | Optional. Non-empty array of values that count as "done" for `completionField` (e.g. `["Done"]`, `["paid", "void"]`). Compared as strings.                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `completionField`      | Optional. Name of the field whose value marks an item as "done" — when set, item-create fires a bell notification that clears once the item reads as done. Must name a real field in `fields`. Two forms: paired with `completionDoneValues` (done ⇔ the field's value is in that array), or naming a **`flag` field** (done ⇔ the flag's `where` matches — `completionDoneValues` must then be omitted).                                                                                                                                                                            |
+| `completionDoneValues` | Optional. Non-empty array of values that count as "done" for `completionField` (e.g. `["Done"]`, `["paid", "void"]`). Compared as strings. Omit when `completionField` names a `flag` field.                                                                                                                                                                                                                                                                                                                                                                                       |
 | `notifyWhen`           | Optional. A `when` predicate (`{ "field": "...", "in": [...] }`) that **gates** the completion bell: fire it only for records matching the predicate (e.g. `{ "field": "priority", "in": ["high", "urgent"] }`). Requires `completionField`; `field` must name a real field. Absent ⇒ notify for every open record.                                                                                                                                                                                                                                                                |
 | `displayField`         | Optional. Name of a field whose value is shown as the human-readable label in the completion notification's title (e.g. `Contacts: Jane Doe` instead of the opaque primaryKey). Must name a real field in `fields`. Falls back to the primaryKey value when unset or when the record's value is empty.                                                                                                                                                                                                                                                                             |
 | `triggerField`         | Optional. Name of a `date` field that **delays** the completion bell until that date arrives (instead of firing on create). Requires `completionField` / `completionDoneValues` (the bell still clears via the done value). Must name a real `date` field. See "Time-gated bells" below.                                                                                                                                                                                                                                                                                           |
@@ -149,7 +149,7 @@ skipped, never crashes the host):
 
 `string` · `text` (multi-line) · `email` · `number` · `date` (`YYYY-MM-DD`) ·
 `datetime` (`YYYY-MM-DDTHH:MM`) · `boolean` · `markdown` · `money` · `enum` ·
-`ref` · `embed` · `backlinks` · `rollup` · `table` · `derived` · `image` · `file` · `toggle`
+`ref` · `embed` · `backlinks` · `rollup` · `table` · `derived` · `image` · `file` · `toggle` · `flag`
 
 Every field spec needs a `type` and a `label`. Extra keys by type:
 
@@ -249,6 +249,20 @@ Every field spec needs a `type` and a `label`. Extra keys by type:
   "done" checkbox. Without it, `status` only shows as a dropdown and a kanban
   column, with no checkbox to tick. `offValue` is the status to return to on
   uncheck (the default open column, e.g. `"Todo"`).
+- **`flag`** — `where: [<conditions>]`. A **computed boolean**: true when the
+  record matches every condition (AND). **Never stored** (like `derived`); the
+  host recomputes it on every read, so you NEVER write flag values into the
+  JSON. Each condition is `{ "field": "<field>", "op": "<op>", "value": "..." }`
+  with ops `eq` / `ne` / `in` (array value) / `contains` / `gt` / `gte` / `lt` /
+  `lte`, or `{ ..., "valueFrom": { "field": "<sibling>" } }` to compare two
+  fields of the same record (`spent > budget`). Condition fields must name
+  declared fields; cross-record `valueFrom.record` is not allowed. A flag may
+  read `derived` / `rollup` values, and other flags via their stringified
+  boolean (`{ "field": "isDone", "op": "eq", "value": "true" }`). Use it for
+  generic state summaries — done-ness, pass/fail, qualification:
+  `{ "type": "flag", "label": "Passed", "where": [{ "field": "score", "op": "gte", "value": "60" }] }`.
+  A flag can also drive completion tracking (stored-field conditions only) —
+  see `completionField` above and the "Completion tracking" section below.
 
 ### Conditional field visibility (`when`)
 
@@ -474,6 +488,16 @@ with any field type whose stringified value is comparable (`enum`, `string`,
 ["paid", "void"]` on an invoice, or `completionField: "shipped"` +
 `completionDoneValues: ["true"]` on an order.
 
+**Flag-form alternative**: `completionField` may instead name a **`flag`
+field** — then done ⇔ the flag's `where` matches, and `completionDoneValues`
+must be **omitted** (declaring it fails validation). Use it when done-ness is
+richer than one field's membership (e.g. `"isDone": { "type": "flag", "where":
+[{ "field": "score", "op": "gte", "value": "60" }] }` + `"completionField":
+"isDone"`). Two extra rules apply only to a completion flag: its `where` may
+reference **stored fields only** (no derived/rollup/toggle/flag/embed/backlinks
+— completion is checked against the raw record), and combining it with `spawn`
+requires an explicit `spawn.when`.
+
 Set `displayField` to make the bell title readable: with `displayField:
 "title"` the notification reads `Todos: Buy milk` instead of `Todos: t-0042`.
 It must name a real field; an empty value on a given record falls back to the

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

@@ -0,0 +1,79 @@
+# Google Calendar sync — mirror a Google calendar into a collection
+
+A collection can keep itself in sync with one of the user's Google calendars.
+Add a `googleCalendar` block to its `schema.json` and the host pulls changed
+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 only calendar mechanism: there is no calendar tool and no bundled
+calendar collection. You author the schema when the user asks for one.
+
+## Requirements
+
+The user's Google account must be linked (`google` tool, `kind: "status"`). If
+it isn't, sync silently does nothing until they link it in settings.
+
+## The block
+
+```jsonc
+{
+  "fields": {
+    "gid":   { "type": "string",   "label": "ID",   "primary": true },
+    "title": { "type": "string",   "label": "Event" },
+    "on":    { "type": "datetime", "label": "Start" },
+    "until": { "type": "datetime", "label": "End" }
+  },
+  "primaryKey": "gid",
+  "displayField": "title",
+  "calendarField": "on",
+  "calendarEndField": "until",
+  "dataPath": "data/collections/my-schedule/items",
+
+  "googleCalendar": {
+    "calendarId": "primary",
+    "map": { "title": "summary", "on": "start", "until": "end" }
+  }
+}
+```
+
+- `calendarId` — the calendar to read. `"primary"` (as in the example) and
+  omitting the key entirely both mean the user's primary calendar. For any
+  other calendar, get its id from the `google` tool
+  (`kind: "calendarListCalendars"`).
+- `map` — **your field name → the Google event field**. Pick whatever field
+  names suit the collection; the map absorbs the difference. Map at least one
+  field: an empty map syncs records that carry only the event id, so the user
+  would see rows with no content.
+
+Mappable event fields: `summary`, `start`, `end`, `htmlLink`, `colorId`,
+`status`.
+
+## The primary field is the event id
+
+Do **not** map the primary field. It always receives the Google event id, which
+is what lets a re-sync update an existing record instead of duplicating it.
+Declaring it in `map` is a schema error.
+
+Use `datetime` (not `date`) for start/end when events have real clock times —
+the calendar day view then draws each record as a proportional time block.
+
+## What sync does
+
+- New or edited events are written, keyed by event id (existing records are
+  replaced in place).
+- Events deleted in Google are **deleted** from the collection.
+- Only what changed since the last run is fetched, so a big calendar stays
+  cheap after the first sync.
+- The first run walks the whole calendar to establish a starting point. Note
+  this covers **all** dates — Google does not allow a date window together with
+  incremental sync — so a calendar with years of history produces a lot of
+  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.
+
+## Not for this
+
+A `dataSource` (CSV-backed) collection is read-only and cannot declare
+`googleCalendar`. Use a normal `dataPath` collection.

package/assets/helps/index.md

@@ -71,6 +71,7 @@ See [Wiki](config/helps/wiki.md) for details on how it works.
 - [Telegram Bridge](config/helps/telegram.md) — how to talk to MulmoClaude from the Telegram app: creating a bot, starting the bridge, allowlisting chat IDs, commands, and troubleshooting
 - [Remote host](config/helps/remote-host.md) — drive MulmoClaude from a phone at mulmoserver.web.app: Google sign-in connect, host online vs. offline (queued chats, 7-day expiry), photo attachments, and the security model
 - [Feeds](config/helps/feeds.md) — register a self-refreshing data feed (RSS/Atom/JSON) by authoring `feeds/<slug>/schema.json`: schema shape, the `ingest` block, raw-item field mapping, and `maxItems` retention
+- [Google Calendar sync](config/helps/google-calendar-collection.md) — mirror a Google calendar into a collection with a `googleCalendar` block: field mapping, why the primary field holds the event id, and how deletions propagate
 - [GitHub repositories in the workspace](config/helps/github.md) — clone-destination rules under `github/<name>/` and how to handle existing directories with matching or different remotes
 - [Collection skills](config/helps/collection-skills.md) — build a data app (model + UI + relations + computed fields + action buttons) by authoring a `schema.json` collection skill: the DSL, field types, derived formulas, actions, records
 - [Custom views](config/helps/custom-view.md) — give a collection a view the built-ins don't cover (year/quarter overview, Gantt): an HTML file under `views/`, registered in `schema.json`, rendered in a sandboxed iframe over the records

package/dist/collection/core/completion.d.ts

@@ -0,0 +1,18 @@
+import { Where } from './where';
+/** The slice of a parsed schema the done predicate reads — minimal
+ *  structural shape (like `DerivableSchema`) so the client and server
+ *  `CollectionSchema` types both satisfy it as-is. */
+export interface CompletionSchemaView {
+    /** Optional so legacy-pair callers (and their test fixtures) that
+     *  never consult field specs keep working; only the flag form needs
+     *  to look the completion field up. */
+    fields?: Record<string, {
+        type: string;
+        where?: Where;
+    }>;
+    completionField?: string;
+    completionDoneValues?: readonly string[];
+}
+/** True iff the schema declares completion tracking AND `item` is done
+ *  under whichever completion form the schema uses (see module doc). */
+export declare function itemIsDone(schema: CompletionSchemaView, item: Record<string, unknown>): boolean;

package/dist/collection/core/deriveAll.d.ts

@@ -1,4 +1,5 @@
 import { FormulaContext } from './derivedFormula';
+import { Where } from './where';
 /** Minimal field shape the derive loop needs — accepts both the client
  *  FieldSpec and the server CollectionFieldSpec. */
 export interface DerivableFieldSpec {
@@ -7,6 +8,8 @@ export interface DerivableFieldSpec {
     to?: string;
     /** When type === "derived": formula evaluated against the record. */
     formula?: string;
+    /** When type === "flag": predicate matched against the record. */
+    where?: Where;
 }
 /** Minimal schema shape: just the ordered field map. */
 export interface DerivableSchema {
@@ -21,17 +24,19 @@ export type DeriveRefRecords = Record<string, Record<string, DerivableRecord>>;
  *  null when dangling / not loaded), keyed by the LOCAL field name —
  *  the shape `evaluateDerived` reads for `<field>.<col>` derefs. */
 export declare function resolveRowRefs(schema: DerivableSchema, record: DerivableRecord, refRecords: DeriveRefRecords): NonNullable<FormulaContext["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.
+/** Evaluate every `derived` and `flag` field against `base`, saturating
+ *  so a computed field can read another one computed in an earlier pass
+ *  (`subtotal → tax → total` converges in ≤ field-count passes; a flag
+ *  may read a derived value, or another flag via its stringified
+ *  boolean). Cycles can't loop forever — passes are bounded by the
+ *  number of computed fields and the loop breaks as soon as a pass
+ *  changes nothing. Failed formulas stay ABSENT (the UI renders them as
+ *  em-dash); flags are total (always true/false). Returns a copy;
+ *  `base` is never mutated.
  *
- *  Derived keys already present in `base` are stripped before
+ *  Computed 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
+ *  fallback. A record JSON can carry a stale (or forged) computed value
  *  — raw Write/Edit, legacy data — and without the strip, a failing
  *  formula would silently surface that value as if the host computed
  *  it. */

package/dist/collection/core/schema.d.ts

@@ -52,10 +52,15 @@ export type CollectionFieldSpec = z.infer<typeof FieldSpecZ>;
  *  `derived` / display-only types (see `SubFieldSpecZ`). */
 export type CollectionSubFieldSpec = z.infer<typeof SubFieldSpecZ>;
 export type CollectionFieldType = CollectionFieldSpec["type"];
-/** derived/embed/backlinks/rollup/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
+/** The computed-boolean variant — a `where` predicate bound to a field
+ *  name; see `FlagFieldZ`. */
+export type CollectionFlagField = Extract<CollectionFieldSpec, {
+    type: "flag";
+}>;
+/** 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. */
 export declare const COMPUTED_TYPES: ReadonlySet<CollectionFieldType>;

package/dist/collection/core/schemaZ.d.ts

@@ -12,6 +12,46 @@ export declare const WhenZ: z.ZodObject<{
     field: z.ZodString;
     in: z.ZodArray<z.ZodString>;
 }, z.core.$strip>;
+export declare const ValueRefZ: z.ZodObject<{
+    record: z.ZodOptional<z.ZodString>;
+    field: z.ZodString;
+}, z.core.$strip>;
+export declare const WhereCondZ: z.ZodObject<{
+    field: z.ZodString;
+    op: z.ZodEnum<{
+        in: "in";
+        eq: "eq";
+        ne: "ne";
+        gt: "gt";
+        gte: "gte";
+        lt: "lt";
+        lte: "lte";
+        contains: "contains";
+    }>;
+    value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    valueFrom: z.ZodOptional<z.ZodObject<{
+        record: z.ZodOptional<z.ZodString>;
+        field: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const WhereZ: z.ZodArray<z.ZodObject<{
+    field: z.ZodString;
+    op: z.ZodEnum<{
+        in: "in";
+        eq: "eq";
+        ne: "ne";
+        gt: "gt";
+        gte: "gte";
+        lt: "lt";
+        lte: "lte";
+        contains: "contains";
+    }>;
+    value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    valueFrom: z.ZodOptional<z.ZodObject<{
+        record: z.ZodOptional<z.ZodString>;
+        field: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>>;
 export declare const SubFieldSpecZ: z.ZodDiscriminatedUnion<[z.ZodObject<{
     label: z.ZodString;
     required: z.ZodOptional<z.ZodBoolean>;
@@ -210,6 +250,33 @@ export declare const FieldSpecZ: z.ZodDiscriminatedUnion<[z.ZodObject<{
         in: z.ZodArray<z.ZodString>;
     }, z.core.$strip>>;
     type: z.ZodLiteral<"toggle">;
+}, z.core.$strip>, z.ZodObject<{
+    where: z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        op: z.ZodEnum<{
+            in: "in";
+            eq: "eq";
+            ne: "ne";
+            gt: "gt";
+            gte: "gte";
+            lt: "lt";
+            lte: "lte";
+            contains: "contains";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        valueFrom: z.ZodOptional<z.ZodObject<{
+            record: z.ZodOptional<z.ZodString>;
+            field: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    label: z.ZodString;
+    primary: z.ZodOptional<z.ZodBoolean>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    when: z.ZodOptional<z.ZodObject<{
+        field: z.ZodString;
+        in: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    type: z.ZodLiteral<"flag">;
 }, z.core.$strip>], "type">;
 /** A schema-declared record action, rendered as a button in the read-only
  *  detail view. Domain-free: the host validates the shape; the meaning
@@ -434,6 +501,24 @@ export declare const AgentIngestZ: z.ZodObject<{
     role: z.ZodString;
     template: z.ZodString;
 }, z.core.$strip>;
+/** The Google event fields a collection may pull from. `id` is absent on
+ *  purpose — it always lands in the primary field, since upsert-by-event-id
+ *  is what makes the sync idempotent. */
+export declare const GOOGLE_CALENDAR_SOURCE_FIELDS: readonly ["summary", "start", "end", "htmlLink", "colorId", "status"];
+/** Marks a collection as the destination of the LLM-free Google Calendar
+ *  sync (#2095). `map` is collectionField → Google event field, so the user's
+ *  collection keeps whatever field names it already uses. */
+export declare const GoogleCalendarSyncZ: z.ZodObject<{
+    calendarId: z.ZodOptional<z.ZodString>;
+    map: z.ZodRecord<z.ZodString, z.ZodEnum<{
+        summary: "summary";
+        start: "start";
+        end: "end";
+        htmlLink: "htmlLink";
+        colorId: "colorId";
+        status: "status";
+    }>>;
+}, z.core.$strip>;
 /** `ingest` is a discriminated union on `kind`: the three declarative
  *  retrievers fetch-and-map; `agent` dispatches a hidden worker. Optional on
  *  every schema — skill-backed collections usually omit it; only feeds
@@ -469,46 +554,6 @@ export declare const IngestZ: z.ZodDiscriminatedUnion<[z.ZodObject<{
     role: z.ZodString;
     template: z.ZodString;
 }, z.core.$strip>], "kind">;
-export declare const ValueRefZ: z.ZodObject<{
-    record: z.ZodOptional<z.ZodString>;
-    field: z.ZodString;
-}, z.core.$strip>;
-export declare const WhereCondZ: z.ZodObject<{
-    field: z.ZodString;
-    op: z.ZodEnum<{
-        in: "in";
-        eq: "eq";
-        ne: "ne";
-        gt: "gt";
-        gte: "gte";
-        lt: "lt";
-        lte: "lte";
-        contains: "contains";
-    }>;
-    value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-    valueFrom: z.ZodOptional<z.ZodObject<{
-        record: z.ZodOptional<z.ZodString>;
-        field: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export declare const WhereZ: z.ZodArray<z.ZodObject<{
-    field: z.ZodString;
-    op: z.ZodEnum<{
-        in: "in";
-        eq: "eq";
-        ne: "ne";
-        gt: "gt";
-        gte: "gte";
-        lt: "lt";
-        lte: "lte";
-        contains: "contains";
-    }>;
-    value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-    valueFrom: z.ZodOptional<z.ZodObject<{
-        record: z.ZodOptional<z.ZodString>;
-        field: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>>;
 export declare const DynamicIconSourceZ: z.ZodObject<{
     collection: z.ZodString;
     from: z.ZodOptional<z.ZodEnum<{
@@ -616,12 +661,12 @@ export declare const DynamicIconSpecZ: z.ZodObject<{
  *  workspace-relative and containment-checked exactly like `dataPath`. The
  *  row-id column is the schema's existing `primaryKey` — there is
  *  deliberately no second key concept here.
- *  See plans/feat-collection-csv-duckdb-source.md. */
+ *  See plans/done/feat-collection-csv-duckdb-source.md. */
 export declare const DataSourceZ: z.ZodObject<{
     type: z.ZodLiteral<"csv">;
     path: z.ZodString;
 }, z.core.$strip>;
-export declare const CollectionSchemaZ: z.ZodObject<{
+export declare const CollectionSchemaZ: z.ZodPreprocess<z.ZodObject<{
     title: z.ZodString;
     icon: z.ZodString;
     dataPath: z.ZodOptional<z.ZodString>;
@@ -799,6 +844,33 @@ export declare const CollectionSchemaZ: z.ZodObject<{
             in: z.ZodArray<z.ZodString>;
         }, z.core.$strip>>;
         type: z.ZodLiteral<"toggle">;
+    }, z.core.$strip>, z.ZodObject<{
+        where: z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                in: "in";
+                eq: "eq";
+                ne: "ne";
+                gt: "gt";
+                gte: "gte";
+                lt: "lt";
+                lte: "lte";
+                contains: "contains";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+            valueFrom: z.ZodOptional<z.ZodObject<{
+                record: z.ZodOptional<z.ZodString>;
+                field: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        label: z.ZodString;
+        primary: z.ZodOptional<z.ZodBoolean>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        when: z.ZodOptional<z.ZodObject<{
+            field: z.ZodString;
+            in: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"flag">;
     }, z.core.$strip>], "type">>;
     actions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         role: z.ZodString;
@@ -1002,6 +1074,17 @@ export declare const CollectionSchemaZ: z.ZodObject<{
         role: z.ZodString;
         template: z.ZodString;
     }, z.core.$strip>], "kind">>;
+    googleCalendar: z.ZodOptional<z.ZodObject<{
+        calendarId: z.ZodOptional<z.ZodString>;
+        map: z.ZodRecord<z.ZodString, z.ZodEnum<{
+            summary: "summary";
+            start: "start";
+            end: "end";
+            htmlLink: "htmlLink";
+            colorId: "colorId";
+            status: "status";
+        }>>;
+    }, z.core.$strip>>;
     dynamicIcon: z.ZodOptional<z.ZodObject<{
         source: z.ZodObject<{
             collection: z.ZodString;
@@ -1053,4 +1136,4 @@ export declare const CollectionSchemaZ: z.ZodObject<{
         }, z.core.$strip>>;
         fallback: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
-}, z.core.$strip>;
+}, z.core.$strip>>;

package/dist/collection/index.cjs

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_promptSafety = require("../promptSafety-DRd15gQ6.cjs");
+const require_ids = require("../ids-BR4U1dJD.cjs");
+const require_promptSafety = require("../promptSafety-Co4cYQ_Z.cjs");
 const require_errorMessage = require("../errorMessage--LvXe_Jx.cjs");
 //#region src/collection/core/presentCollection.ts
 var TOOL_NAME = "presentCollection";
@@ -225,7 +226,7 @@ function rowDraftToRecord(rowDraft, subFields) {
 function draftToRecord(state, schema) {
 	const record = {};
 	for (const [key, field] of Object.entries(schema.fields)) {
-		if (require_promptSafety.COMPUTED_TYPES.has(field.type)) continue;
+		if (require_ids.COMPUTED_TYPES.has(field.type)) continue;
 		if (field.type === "boolean") {
 			if (shouldEmitBoolean(state, key, field)) record[key] = state.bool[key] === true;
 			continue;
@@ -281,7 +282,7 @@ function firstMissingTableSubField(field, rows) {
 *  value, and the computed/projected kinds (COMPUTED_TYPES — the shared
 *  set, so a future computed type can't drift past this check) have no
 *  draft input at all. */
-var NEVER_MISSING_TYPES = /* @__PURE__ */ new Set(["boolean", ...require_promptSafety.COMPUTED_TYPES]);
+var NEVER_MISSING_TYPES = /* @__PURE__ */ new Set(["boolean", ...require_ids.COMPUTED_TYPES]);
 function validateOneField(key, field, draft, record) {
 	if (!require_promptSafety.fieldVisible(field, record)) return null;
 	if (field.type === "table" && field.of) {
@@ -436,16 +437,16 @@ function shortHexId() {
 	return crypto.randomUUID().replace(/-/g, "").slice(0, 8);
 }
 //#endregion
-exports.AGENT_INGEST_KIND = require_promptSafety.AGENT_INGEST_KIND;
-exports.COMPUTED_TYPES = require_promptSafety.COMPUTED_TYPES;
+exports.AGENT_INGEST_KIND = require_ids.AGENT_INGEST_KIND;
+exports.COMPUTED_TYPES = require_ids.COMPUTED_TYPES;
 exports.ENUM_ALERT = ENUM_ALERT;
 exports.ENUM_NEUTRAL = ENUM_NEUTRAL;
 exports.ENUM_NUDGE = ENUM_NUDGE;
-exports.FEED_SCHEDULES = require_promptSafety.FEED_SCHEDULES;
-exports.INGEST_KINDS = require_promptSafety.INGEST_KINDS;
+exports.FEED_SCHEDULES = require_ids.FEED_SCHEDULES;
+exports.INGEST_KINDS = require_ids.INGEST_KINDS;
 exports.MINUTES_PER_DAY = require_promptSafety.MINUTES_PER_DAY;
-exports.SAFE_RECORD_ID_PATTERN = require_promptSafety.SAFE_RECORD_ID_PATTERN;
-exports.SAFE_SLUG_PATTERN = require_promptSafety.SAFE_SLUG_PATTERN;
+exports.SAFE_RECORD_ID_PATTERN = require_ids.SAFE_RECORD_ID_PATTERN;
+exports.SAFE_SLUG_PATTERN = require_ids.SAFE_SLUG_PATTERN;
 exports.TOOL_DEFINITION = TOOL_DEFINITION;
 exports.TOOL_NAME = TOOL_NAME;
 exports.actionVisible = require_promptSafety.actionVisible;
@@ -466,7 +467,7 @@ exports.daySlice = require_promptSafety.daySlice;
 exports.defangForPrompt = require_promptSafety.defangForPrompt;
 exports.deriveAll = require_promptSafety.deriveAll;
 exports.draftToRecord = draftToRecord;
-exports.embedTargetId = require_promptSafety.embedTargetId;
+exports.embedTargetId = require_ids.embedTargetId;
 exports.emptyRow = emptyRow;
 exports.enumColorClasses = enumColorClasses;
 exports.enumSortValue = enumSortValue;
@@ -477,12 +478,13 @@ exports.executePresentCollection = executePresentCollection;
 exports.fieldVisible = require_promptSafety.fieldVisible;
 exports.firstDateField = require_promptSafety.firstDateField;
 exports.firstMissingRequiredField = firstMissingRequiredField;
-exports.isFieldDrivenEvery = require_promptSafety.isFieldDrivenEvery;
-exports.isReadOnlySchema = require_promptSafety.isReadOnlySchema;
-exports.isSafeRecordId = require_promptSafety.isSafeRecordId;
-exports.isSafeSlug = require_promptSafety.isSafeSlug;
+exports.isFieldDrivenEvery = require_ids.isFieldDrivenEvery;
+exports.isReadOnlySchema = require_ids.isReadOnlySchema;
+exports.isSafeRecordId = require_ids.isSafeRecordId;
+exports.isSafeSlug = require_ids.isSafeSlug;
 exports.isSortableField = isSortableField;
 exports.itemIdOf = itemIdOf;
+exports.itemIsDone = require_promptSafety.itemIsDone;
 exports.itemLabelOf = itemLabelOf;
 exports.labelFieldFor = labelFieldFor;
 exports.matchesWhere = require_promptSafety.matchesWhere;