things-api 0.14.0 → 0.15.0

package/dist/write/commands.js

@@ -1,5 +1,6 @@
 import { decodeReminderTime, encodeReminderTime, localToday, reminderUrlToken, zonedWallInstant, } from "../model/dates.js";
 import { byUuid } from "../read/detail.js";
+import { manualLogDateEpoch, pendingLogCount } from "../read/log-boundary.js";
 import { isLooseRef } from "../read/pseudo-area.js";
 import { reminderIsLive } from "../read/stage.js";
 import { areaMemberCounts, childTagTitles, classifyHeadingConvert, classifyHeadingDissolve, classifyHeadingMoveToProject, classifyProjectRepeat, computeHeadingMovePre, computeReorderPre, emptyPreState, loadTarget, projectChildren, projectStatus, projectSubtreeUuids, resolveArea, resolveHeading, resolveProject, resolveTag, sameTitleTaskUuids, trashedCount, } from "./pre-state.js";
@@ -62,7 +63,7 @@ function q(value) {
 function unsupportedVector(op, vector) {
     throw new Error(`${op} cannot be compiled for vector ${vector} (planner bug)`);
 }
-function whenAssertions(when, todayIso) {
+function whenAssertions(when, todayIso, opts = { mode: "add" }) {
     // Strict shape check: an unvalidated string used to flow straight into the
     // URL (e.g. "2026-07-20@09:30", the raw URL grammar) — the app would SET
     // date+reminder while verification asserted the literal string as the date,
@@ -78,16 +79,35 @@ function whenAssertions(when, todayIso) {
     }
     switch (when) {
         case "today":
+            // Today's non-evening section: in Today (the `today` marker) AND NOT in the
+            // evening sub-bucket (the presence-keyed `evening` marker absent — asserted
+            // as null, which valuesEqual treats as absent). Gated to Today members under
+            // the verify clock exactly as the retired `todaySection` was.
+            //
+            // The `startDate` assertion differs by op (field bug §0½.8):
+            //  - ADD mints a fresh Today item with no schedule history, so the app dates
+            //    it EXACTLY today — exact equality is right.
+            //  - UPDATE of an item ALREADY in Today whose `startDate` has already arrived
+            //    (past or today): the app PRESERVES that historical date rather than
+            //    rewriting the storage byte to today (arrived-date law). Assert the
+            //    arrived-date PREDICATE (non-null and <= today) so a preserved historical
+            //    date verifies, while an undated deadline-only pull (null startDate) is
+            //    still rejected — the item's Today membership then rests only on a
+            //    deadline, not on the requested schedule.
             return [
                 { field: "start", equals: "active" },
-                { field: "startDate", equals: todayIso },
-                { field: "todaySection", equals: "today" },
+                opts.mode === "update"
+                    ? { field: "startDate", satisfies: { predicate: "arrived-on-or-before", date: todayIso } }
+                    : { field: "startDate", equals: todayIso },
+                { field: "today", equals: true },
+                { field: "evening", equals: null },
             ];
         case "evening":
+            // The This-Evening sub-bucket: the `evening` marker (which implies `today`).
             return [
                 { field: "start", equals: "active" },
                 { field: "startDate", equals: todayIso },
-                { field: "todaySection", equals: "evening" },
+                { field: "evening", equals: true },
             ];
         case "anytime":
             return [
@@ -304,8 +324,11 @@ const todoAdd = {
             }
             if (params.tags !== undefined)
                 attrs["tags"] = pre.resolvedTagTitles;
-            if (params.checklistItems !== undefined)
-                attrs["checklist-items"] = params.checklistItems;
+            if (params.checklistItems !== undefined) {
+                // §9y: things:///json rejects a bare STRING array wholesale (silent
+                // no-op) — emit the OBJECT-array shape the app accepts.
+                attrs["checklist-items"] = checklistItemsJsonAttr(params.checklistItems.map((title) => ({ title })));
+            }
             if (container?.uuid !== undefined)
                 attrs["list-id"] = container.uuid;
             if (pre.destHeading?.resolved?.title !== undefined) {
@@ -353,7 +376,12 @@ function effectiveReminder(pre, params) {
         return null;
     if (!reminderIsLive(target.startDate, pre.todayIso))
         return null;
-    return target.reminder;
+    // Read the RAW stored byte off the substrate (top-level `reminder` is
+    // live-gated under the LOAD clock, which can differ from `pre.todayIso` under a
+    // pinned THINGS_NOW). The `reminderIsLive` guard above applies liveness under
+    // the injected clock explicitly, so the raw byte + this gate reproduce the
+    // former semantics exactly.
+    return target.derived.reminder;
 }
 function assertNotesModesExclusive(params) {
     if (params.notes !== undefined &&
@@ -396,7 +424,7 @@ const todoUpdate = {
         if (joined !== undefined)
             assert.push({ field: "notes", equals: joined });
         if (params.when !== undefined) {
-            assert.push(...whenAssertions(params.when, ctx.todayIso));
+            assert.push(...whenAssertions(params.when, ctx.todayIso, { mode: "update" }));
             const reminder = effectiveReminder(pre, params);
             assert.push({
                 field: "reminder",
@@ -601,6 +629,21 @@ const todoSetTags = {
     },
 };
 /** Normalize the string | spec union; decide whether states force the json form. */
+/**
+ * The `checklist-items` value `things:///json` accepts: an array of
+ * `{type:"checklist-item",attributes:{title[,completed]}}` OBJECTS. A bare
+ * STRING array is rejected wholesale — the whole import silently no-ops, no row,
+ * no error (§9y; RESID1 R-JSONPAR RAW-a..d). `completed` is emitted only when a
+ * spec carries it, so an at-creation add (all items open) yields the minimal
+ * `{title}` attributes the probe validated (OBJ/OBJ3), while the checklist
+ * replace path forwards its per-item state.
+ */
+function checklistItemsJsonAttr(specs) {
+    return specs.map((s) => ({
+        type: "checklist-item",
+        attributes: s.completed === undefined ? { title: s.title } : { title: s.title, completed: s.completed },
+    }));
+}
 function checklistSpecs(items) {
     const specs = items.map((i) => typeof i === "string"
         ? { title: i, completed: false }
@@ -647,10 +690,7 @@ const todoReplaceChecklist = {
                 operation: "update",
                 id: params.uuid,
                 attributes: {
-                    "checklist-items": specs.map((s) => ({
-                        type: "checklist-item",
-                        attributes: { title: s.title, completed: s.completed },
-                    })),
+                    "checklist-items": checklistItemsJsonAttr(specs),
                 },
             },
         ]);
@@ -787,7 +827,7 @@ const projectUpdate = {
         if (joined !== undefined)
             assert.push({ field: "notes", equals: joined });
         if (params.when !== undefined) {
-            assert.push(...whenAssertions(params.when, ctx.todayIso));
+            assert.push(...whenAssertions(params.when, ctx.todayIso, { mode: "update" }));
             // Projects carry the same reminderTime codec as to-dos (A3); a bare
             // when= clears an existing reminder unless auto-preserved.
             const reminder = effectiveReminder(pre, params);
@@ -1390,6 +1430,13 @@ const reorder = {
         // Verify the REQUESTED sequence (strictly ascending ranks). The wire
         // list pins the unrequested tail too, but the caller's contract is the
         // requested prefix; tail members are covered by pre-rank tripwires.
+        // TODWIRE: on the `today` scope the wire is now MINIMAL — only the named
+        // block gets fresh (front, monotonic) `todayIndex`; the unnamed tail keeps
+        // its cohort-interleaved (non-monotonic) `todayIndex`, so the FULL
+        // `params.uuids` is NOT strictly-ascending after the write. Verify the
+        // `todayWire` (the named block) instead — it lands at the visible front in
+        // wire order with fresh ascending values, and the untouched tail rides the
+        // pre-rank tripwires. Every other scope verifies the requested prefix.
         // LOGSORT ORD-13 byte-lock: any admitted UNSWEPT-resolved movee must read
         // back index-only — status still closed, stoppedDate intact, umd unbumped
         // (a reopen would flip all three). Frozen assertions carry that into verify.
@@ -1400,11 +1447,14 @@ const reorder = {
                 { field: "stoppedDate", equals: m.stoppedDate },
             ],
         }));
+        const sequence = params.scope === "today" && pre.reorder?.todayWire != null
+            ? pre.reorder.todayWire
+            : params.uuids;
         return {
             mode: "ordering",
             key: pre.reorder?.key ??
                 (params.scope === "today" || params.scope === "evening" ? "todayIndex" : "index"),
-            sequence: params.uuids,
+            sequence,
             ...(frozen.length > 0 && { frozen }),
         };
     },
@@ -1429,7 +1479,14 @@ const reorder = {
                                 : params.scope === "upcoming"
                                     ? `list "Upcoming"`
                                     : `list "Today"`;
-        const wire = pre.reorder?.wireList ?? params.uuids;
+        // TODWIRE — the `today` scope sends the MINIMAL visible-order wire (names only
+        // what must move; unnamed rows keep their entry cohorts + visible positions),
+        // not the OLD full `wireList` that fused every cohort (MOVPLC/ORD-20). Every
+        // other native scope keeps the full wire (their `index`/day axes do not
+        // re-stamp `tiRef`, so a full re-rank is non-damaging).
+        const wire = (params.scope === "today" ? pre.reorder?.todayWire : undefined) ??
+            pre.reorder?.wireList ??
+            params.uuids;
         if (params.scope === "someday") {
             // The Someday handler STACKS each sent id above the list's current top
             // (the current top itself never moves), with OPPOSITE stack directions
@@ -1514,8 +1571,8 @@ function setDatesSpec(op, addressor) {
         op,
         hazards: ["H-UNKNOWN-DESTINATION", "H-BACKDATE-OPEN"],
         preRead(db, params) {
-            if (params.completionDate === undefined && params.creationDate === undefined) {
-                throw new RangeError("nothing to set: give completionDate and/or creationDate");
+            if (params.completedAt === undefined && params.createdAt === undefined) {
+                throw new RangeError("nothing to set: give completedAt and/or createdAt");
             }
             const pre = emptyPreState();
             pre.target = loadTarget(db, params.uuid);
@@ -1523,16 +1580,16 @@ function setDatesSpec(op, addressor) {
         },
         expectedDelta(_pre, params, ctx) {
             const assert = [];
-            if (params.completionDate !== undefined) {
+            if (params.completedAt !== undefined) {
                 assert.push({
                     field: "stoppedDate",
-                    equals: hostLocalDate(resolveResolutionInstant(params.completionDate, ctx.zone)),
+                    equals: hostLocalDate(resolveResolutionInstant(params.completedAt, ctx.zone)),
                 });
             }
-            if (params.creationDate !== undefined) {
+            if (params.createdAt !== undefined) {
                 assert.push({
                     field: "createdDate",
-                    equals: hostLocalDate(resolveResolutionInstant(params.creationDate, ctx.zone)),
+                    equals: hostLocalDate(resolveResolutionInstant(params.createdAt, ctx.zone)),
                 });
             }
             return { mode: "update", uuid: params.uuid, assert };
@@ -1541,11 +1598,11 @@ function setDatesSpec(op, addressor) {
             if (vector !== "applescript")
                 unsupportedVector(this.op, vector);
             const statements = [];
-            if (params.completionDate !== undefined) {
-                statements.push(...asDateBlockFromInstant("compDate", resolveResolutionInstant(params.completionDate, ctx.zone)), `set completion date of ${addressor} id ${q(params.uuid)} to compDate`);
+            if (params.completedAt !== undefined) {
+                statements.push(...asDateBlockFromInstant("compDate", resolveResolutionInstant(params.completedAt, ctx.zone)), `set completion date of ${addressor} id ${q(params.uuid)} to compDate`);
             }
-            if (params.creationDate !== undefined) {
-                statements.push(...asDateBlockFromInstant("createDate", resolveResolutionInstant(params.creationDate, ctx.zone)), `set creation date of ${addressor} id ${q(params.uuid)} to createDate`);
+            if (params.createdAt !== undefined) {
+                statements.push(...asDateBlockFromInstant("createDate", resolveResolutionInstant(params.createdAt, ctx.zone)), `set creation date of ${addressor} id ${q(params.uuid)} to createDate`);
             }
             return osaBlock(statements);
         },
@@ -2356,6 +2413,29 @@ const trashEmpty = {
         return osa("empty trash");
     },
 };
+const logNow = {
+    op: "log-now",
+    hazards: [],
+    preRead(db, _params, now, zone) {
+        const pre = emptyPreState();
+        // The resolved-but-unlogged census the verb will move (the disclosed count),
+        // and the pre-op boundary stamp the delta compares against.
+        pre.logNow = {
+            pending: pendingLogCount(db, now, zone),
+            manualLogDatePre: manualLogDateEpoch(db),
+        };
+        return pre;
+    },
+    expectedDelta(pre) {
+        const ln = pre.logNow ?? { pending: 0, manualLogDatePre: null };
+        return { mode: "logged-now", pending: ln.pending, manualLogDatePre: ln.manualLogDatePre };
+    },
+    compile(_params, vector) {
+        if (vector !== "applescript")
+            unsupportedVector(this.op, vector);
+        return osa("log completed now");
+    },
+};
 export const COMMANDS = {
     "todo.add": todoAdd,
     "todo.update": todoUpdate,
@@ -2409,5 +2489,6 @@ export const COMMANDS = {
     "area.reorder": areaReorderSidebar,
     "project.make-repeating": projectMakeRepeating,
     "project.add-repeating": projectAddRepeating,
+    "log-now": logNow,
 };
 //# sourceMappingURL=commands.js.map