things-api 0.5.0

package/dist/write/commands.js

@@ -0,0 +1,1274 @@
+import { decodeReminderTime, encodeReminderTime, reminderUrlToken, } from "../model/dates.js";
+import { childTagTitles, computeReorderPre, emptyPreState, loadTarget, missingTagTitles, projectChildren, projectStatus, resolveArea, resolveHeading, resolveProject, resolveTag, trashedCount, } from "./pre-state.js";
+import { PRIVATE_REORDER_COMMAND } from "./experimental.js";
+import { escapeAppleScript } from "./vectors/applescript.js";
+// ------------------------------------------------------------------ helpers
+function thingsUrl(command, params, token) {
+    const parts = [];
+    const redactedParts = [];
+    for (const [key, value] of Object.entries(params)) {
+        if (value === undefined)
+            continue;
+        parts.push(`${key}=${encodeURIComponent(value)}`);
+        redactedParts.push(`${key}=${encodeURIComponent(value)}`);
+    }
+    if (token !== null) {
+        parts.push(`auth-token=${encodeURIComponent(token)}`);
+        redactedParts.push("auth-token=REDACTED");
+    }
+    return {
+        vector: "url-scheme",
+        kind: "open-url",
+        payload: `things:///${command}?${parts.join("&")}`,
+        redactedPayload: `things:///${command}?${redactedParts.join("&")}`,
+    };
+}
+function osa(script) {
+    const payload = `tell application "Things3" to ${script}`;
+    return { vector: "applescript", kind: "osascript", payload, redactedPayload: payload };
+}
+/** Multi-statement `tell` block (one osascript invocation, several events). */
+function osaBlock(statements) {
+    const payload = `tell application "Things3"\n  ${statements.join("\n  ")}\nend tell`;
+    return { vector: "applescript", kind: "osascript", payload, redactedPayload: payload };
+}
+function q(value) {
+    return `"${escapeAppleScript(value)}"`;
+}
+function unsupportedVector(op, vector) {
+    throw new Error(`${op} cannot be compiled for vector ${vector} (planner bug)`);
+}
+function whenAssertions(when, todayIso) {
+    switch (when) {
+        case "today":
+            return [
+                { field: "start", equals: "active" },
+                { field: "startDate", equals: todayIso },
+                { field: "todaySection", equals: "today" },
+            ];
+        case "evening":
+            return [
+                { field: "start", equals: "active" },
+                { field: "startDate", equals: todayIso },
+                { field: "todaySection", equals: "evening" },
+            ];
+        case "anytime":
+            return [
+                { field: "start", equals: "active" },
+                { field: "startDate", equals: null },
+            ];
+        case "someday":
+            return [{ field: "start", equals: "someday" }];
+        default:
+            // Concrete date: assert only the date — start-state semantics differ
+            // for past/today/future dates (only the date itself is invariant).
+            return [{ field: "startDate", equals: when }];
+    }
+}
+function sortedTags(tags) {
+    return [...tags].toSorted();
+}
+/** Round-trip normalization: "6:5"-style inputs → canonical "06:05". */
+function normalizeReminder(time) {
+    return decodeReminderTime(encodeReminderTime(time)) ?? time;
+}
+/**
+ * The URL `when` value with an optional reminder token appended through the
+ * deterministic emitter (never a bare 1–11 hour — oddity 2d).
+ */
+function whenWithReminder(when, reminder) {
+    if (reminder === undefined || reminder === null)
+        return when;
+    return `${when}@${reminderUrlToken(reminder)}`;
+}
+function containerGiven(ref) {
+    return ref !== undefined && (ref.uuid !== undefined || ref.title !== undefined);
+}
+// ----------------------------------------------------------------- commands
+const todoAdd = {
+    op: "todo.add",
+    hazards: [
+        "H-UNKNOWN-TAG",
+        "H-UNKNOWN-DESTINATION",
+        "H-AMBIGUOUS-HEADING",
+        "H-REOPEN-RESOLVED-PROJECT",
+        "H-REMINDER-SCOPE",
+    ],
+    preRead(db, params) {
+        const pre = emptyPreState();
+        if (containerGiven(params.project)) {
+            pre.destProject = resolveProject(db, params.project);
+            if (pre.destProject.resolved !== null) {
+                pre.destProjectStatus = projectStatus(db, pre.destProject.resolved.uuid);
+                if (params.heading !== undefined) {
+                    pre.destHeading = resolveHeading(db, pre.destProject.resolved.uuid, params.heading);
+                }
+            }
+        }
+        if (containerGiven(params.area))
+            pre.destArea = resolveArea(db, params.area);
+        if (params.tags !== undefined)
+            pre.missingTags = missingTagTitles(db, params.tags);
+        return pre;
+    },
+    expectedDelta(pre, params, ctx) {
+        const assert = [];
+        if (params.notes !== undefined)
+            assert.push({ field: "notes", equals: params.notes });
+        if (params.when !== undefined)
+            assert.push(...whenAssertions(params.when, ctx.todayIso));
+        if (params.reminder !== undefined) {
+            assert.push({ field: "reminder", equals: normalizeReminder(params.reminder) });
+        }
+        if (params.deadline !== undefined)
+            assert.push({ field: "deadline", equals: params.deadline });
+        if (params.tags !== undefined)
+            assert.push({ field: "tags", equals: sortedTags(params.tags) });
+        if (params.checklistItems !== undefined) {
+            assert.push({ field: "checklistTitles", equals: params.checklistItems });
+        }
+        const heading = pre.destHeading?.resolved;
+        const project = pre.destProject?.resolved;
+        if (heading !== undefined && heading !== null) {
+            assert.push({ field: "heading.uuid", equals: heading.uuid });
+        }
+        else if (project !== undefined && project !== null) {
+            assert.push({ field: "project.uuid", equals: project.uuid });
+        }
+        const area = pre.destArea?.resolved;
+        if (area !== undefined && area !== null)
+            assert.push({ field: "area.uuid", equals: area.uuid });
+        return {
+            mode: "create",
+            probe: { title: params.title, type: "to-do", sinceEpoch: ctx.nowEpoch - 2 },
+            assert,
+        };
+    },
+    compile(params, vector, pre, ctx) {
+        if (vector !== "url-scheme")
+            unsupportedVector(this.op, vector);
+        const container = pre.destProject?.resolved ?? pre.destArea?.resolved;
+        return thingsUrl("add", {
+            title: params.title,
+            notes: params.notes,
+            when: params.when === undefined ? undefined : whenWithReminder(params.when, params.reminder),
+            deadline: params.deadline,
+            tags: params.tags?.join(","),
+            "checklist-items": params.checklistItems?.join("\n"),
+            "list-id": container?.uuid,
+            heading: pre.destHeading?.resolved?.title,
+        }, ctx.token);
+    },
+};
+/**
+ * The effective reminder a when-bearing update should leave behind. A bare
+ * `when=` CLEARS an existing reminder (R07/R20), so when the caller
+ * re-schedules to today/evening/a date without addressing the reminder we
+ * auto-preserve the current one; an explicit null is the intentional clear.
+ */
+function effectiveReminder(pre, params) {
+    if (params.reminder !== undefined)
+        return params.reminder;
+    const when = params.when;
+    const schedulable = when === "today" ||
+        when === "evening" ||
+        (typeof when === "string" && /^\d{4}-\d{2}-\d{2}$/.test(when));
+    if (!schedulable)
+        return null;
+    const target = pre.target;
+    if (target === null || target.type === "heading")
+        return null;
+    return target.reminder;
+}
+function assertNotesModesExclusive(params) {
+    if (params.notes !== undefined &&
+        (params.appendNotes !== undefined || params.prependNotes !== undefined)) {
+        throw new RangeError("notes (replace) is exclusive with appendNotes/prependNotes");
+    }
+    if (params.appendNotes !== undefined && params.prependNotes !== undefined) {
+        throw new RangeError("appendNotes and prependNotes cannot be combined in one update");
+    }
+}
+function expectedNotes(pre, params) {
+    const current = pre.target !== null && pre.target.type !== "heading" ? pre.target.notes : "";
+    // Separator semantics probed: newline-joined, no stray newline against an
+    // empty note (E04/E05/E11/E12).
+    if (params.appendNotes !== undefined) {
+        return current === "" ? params.appendNotes : `${current}\n${params.appendNotes}`;
+    }
+    if (params.prependNotes !== undefined) {
+        return current === "" ? params.prependNotes : `${params.prependNotes}\n${current}`;
+    }
+    return undefined;
+}
+const todoUpdate = {
+    op: "todo.update",
+    hazards: ["H-UNKNOWN-DESTINATION", "H-REPEAT-SCHEDULE", "H-REMINDER-SCOPE"],
+    preRead(db, params) {
+        assertNotesModesExclusive(params);
+        const pre = emptyPreState();
+        pre.target = loadTarget(db, params.uuid);
+        return pre;
+    },
+    expectedDelta(pre, params, ctx) {
+        const assert = [];
+        if (params.title !== undefined)
+            assert.push({ field: "title", equals: params.title });
+        if (params.notes !== undefined)
+            assert.push({ field: "notes", equals: params.notes });
+        const joined = expectedNotes(pre, params);
+        if (joined !== undefined)
+            assert.push({ field: "notes", equals: joined });
+        if (params.when !== undefined) {
+            assert.push(...whenAssertions(params.when, ctx.todayIso));
+            const reminder = effectiveReminder(pre, params);
+            assert.push({
+                field: "reminder",
+                equals: reminder === null ? null : normalizeReminder(reminder),
+            });
+        }
+        if (params.deadline !== undefined)
+            assert.push({ field: "deadline", equals: params.deadline });
+        return { mode: "update", uuid: params.uuid, assert };
+    },
+    compile(params, vector, pre, ctx) {
+        if (vector !== "url-scheme")
+            unsupportedVector(this.op, vector);
+        return thingsUrl("update", {
+            id: params.uuid,
+            title: params.title,
+            notes: params.notes,
+            "append-notes": params.appendNotes,
+            "prepend-notes": params.prependNotes,
+            when: params.when === undefined
+                ? undefined
+                : whenWithReminder(params.when, effectiveReminder(pre, params)),
+            deadline: params.deadline === null ? "" : params.deadline,
+        }, ctx.token);
+    },
+};
+function statusSpec(op, urlParam, asStatus, scriptStatus) {
+    return {
+        op,
+        hazards: ["H-UNKNOWN-DESTINATION", "H-REPEAT-SCHEDULE"],
+        preRead(db, params) {
+            const pre = emptyPreState();
+            pre.target = loadTarget(db, params.uuid);
+            return pre;
+        },
+        expectedDelta(_pre, params) {
+            return { mode: "state", uuid: params.uuid, assert: [{ field: "status", equals: asStatus }] };
+        },
+        compile(params, vector, _pre, ctx) {
+            if (vector === "url-scheme") {
+                return thingsUrl("update", { id: params.uuid, ...urlParam }, ctx.token);
+            }
+            return osa(`set status of to do id ${q(params.uuid)} to ${scriptStatus}`);
+        },
+    };
+}
+const todoComplete = statusSpec("todo.complete", { completed: "true" }, "completed", "completed");
+const todoCancel = statusSpec("todo.cancel", { canceled: "true" }, "canceled", "canceled");
+const todoReopen = statusSpec("todo.reopen", { completed: "false" }, "open", "open");
+const todoMove = {
+    op: "todo.move",
+    hazards: [
+        "H-UNKNOWN-DESTINATION",
+        "H-AMBIGUOUS-HEADING",
+        "H-REOPEN-RESOLVED-PROJECT",
+        "H-REPEAT-SCHEDULE",
+    ],
+    preRead(db, params) {
+        const container = containerGiven(params.project) || containerGiven(params.area) || params.heading !== undefined;
+        if (params.inbox === true && (container || params.detach === true)) {
+            throw new RangeError("inbox is exclusive with project/area/heading/detach");
+        }
+        if (params.detach === true && container) {
+            throw new RangeError("detach is exclusive with project/area/heading destinations");
+        }
+        const pre = emptyPreState();
+        pre.target = loadTarget(db, params.uuid);
+        if (containerGiven(params.project)) {
+            pre.destProject = resolveProject(db, params.project);
+            if (pre.destProject.resolved !== null) {
+                pre.destProjectStatus = projectStatus(db, pre.destProject.resolved.uuid);
+                if (params.heading !== undefined) {
+                    pre.destHeading = resolveHeading(db, pre.destProject.resolved.uuid, params.heading);
+                }
+            }
+        }
+        if (containerGiven(params.area))
+            pre.destArea = resolveArea(db, params.area);
+        return pre;
+    },
+    expectedDelta(pre, params) {
+        const assert = [];
+        if (params.inbox === true) {
+            // De-schedules cleanly (E06): back to the Inbox bucket, no start date.
+            assert.push({ field: "start", equals: "inbox" }, { field: "startDate", equals: null });
+            return { mode: "update", uuid: params.uuid, assert };
+        }
+        if (params.detach === true) {
+            // P21/P22: empty list-id strips every container link; the schedule is
+            // untouched (pin it — a silent de-schedule would be a contrary write).
+            const target = pre.target;
+            const startDate = target !== null && target.type !== "heading" ? (target.startDate ?? null) : null;
+            assert.push({ field: "project", equals: null }, { field: "area", equals: null }, { field: "heading", equals: null }, { field: "startDate", equals: startDate });
+            return { mode: "update", uuid: params.uuid, assert };
+        }
+        const heading = pre.destHeading?.resolved;
+        const project = pre.destProject?.resolved;
+        const area = pre.destArea?.resolved;
+        if (heading !== undefined && heading !== null) {
+            assert.push({ field: "heading.uuid", equals: heading.uuid });
+        }
+        else if (project !== undefined && project !== null) {
+            assert.push({ field: "project.uuid", equals: project.uuid });
+        }
+        if (area !== undefined && area !== null) {
+            assert.push({ field: "area.uuid", equals: area.uuid });
+            // Validated (A22B): assigning an area clears any project link.
+            assert.push({ field: "project", equals: null });
+        }
+        return { mode: "update", uuid: params.uuid, assert };
+    },
+    compile(params, vector, pre, ctx) {
+        if (params.inbox === true) {
+            if (vector !== "applescript")
+                unsupportedVector(this.op, vector);
+            return osa(`move to do id ${q(params.uuid)} to list "Inbox"`);
+        }
+        if (params.detach === true) {
+            // Empty list-id = clear the container (P21/P22) — URL only; the other
+            // vectors reject or silently ignore container removal (P10/P11, P26).
+            if (vector !== "url-scheme")
+                unsupportedVector(this.op, vector);
+            return thingsUrl("update", { id: params.uuid, "list-id": "" }, ctx.token);
+        }
+        const project = pre.destProject?.resolved;
+        const area = pre.destArea?.resolved;
+        if (vector === "url-scheme") {
+            return thingsUrl("update", {
+                id: params.uuid,
+                "list-id": (project ?? area)?.uuid,
+                heading: pre.destHeading?.resolved?.title,
+            }, ctx.token);
+        }
+        if (project !== undefined && project !== null) {
+            return osa(`set project of to do id ${q(params.uuid)} to project id ${q(project.uuid)}`);
+        }
+        if (area !== undefined && area !== null) {
+            return osa(`set area of to do id ${q(params.uuid)} to area id ${q(area.uuid)}`);
+        }
+        unsupportedVector(this.op, vector);
+    },
+};
+const todoSetTags = {
+    op: "todo.set-tags",
+    hazards: ["H-UNKNOWN-DESTINATION", "H-UNKNOWN-TAG"],
+    preRead(db, params) {
+        const pre = emptyPreState();
+        pre.target = loadTarget(db, params.uuid);
+        pre.missingTags = missingTagTitles(db, params.tags);
+        return pre;
+    },
+    expectedDelta(_pre, params) {
+        return {
+            mode: "update",
+            uuid: params.uuid,
+            assert: [{ field: "tags", equals: sortedTags(params.tags) }],
+        };
+    },
+    compile(params, vector, _pre, ctx) {
+        if (vector === "url-scheme") {
+            return thingsUrl("update", { id: params.uuid, tags: params.tags.join(",") }, ctx.token);
+        }
+        return osa(`set tag names of to do id ${q(params.uuid)} to ${q(params.tags.join(", "))}`);
+    },
+};
+/** Normalize the string | spec union; decide whether states force the json form. */
+function checklistSpecs(items) {
+    const specs = items.map((i) => typeof i === "string"
+        ? { title: i, completed: false }
+        : { title: i.title, completed: i.completed === true });
+    const needsJson = items.some((i) => typeof i !== "string" && i.completed !== undefined);
+    return { specs, needsJson };
+}
+const todoReplaceChecklist = {
+    op: "todo.replace-checklist",
+    hazards: ["H-UNKNOWN-DESTINATION", "H-CHECKLIST-REPLACE"],
+    preRead(db, params) {
+        const pre = emptyPreState();
+        pre.target = loadTarget(db, params.uuid);
+        if (pre.target !== null && pre.target.type === "to-do") {
+            pre.checklistCount = pre.target.checklist?.length ?? 0;
+        }
+        return pre;
+    },
+    expectedDelta(_pre, params) {
+        const { specs, needsJson } = checklistSpecs(params.items);
+        const assert = [
+            { field: "checklistTitles", equals: specs.map((s) => s.title) },
+        ];
+        if (needsJson) {
+            // P18: the json form applies per-item completed states — verify them.
+            assert.push({
+                field: "checklistStates",
+                equals: specs.map((s) => (s.completed ? "completed" : "open")),
+            });
+        }
+        return { mode: "update", uuid: params.uuid, assert };
+    },
+    compile(params, vector, _pre, ctx) {
+        if (vector !== "url-scheme")
+            unsupportedVector(this.op, vector);
+        const { specs, needsJson } = checklistSpecs(params.items);
+        if (!needsJson) {
+            return thingsUrl("update", { id: params.uuid, "checklist-items": specs.map((s) => s.title).join("\n") }, ctx.token);
+        }
+        // things:///json — the only surface that recreates items PRE-CHECKED
+        // (P18). Items are replaced wholesale; their uuids are not stable.
+        const payload = JSON.stringify([
+            {
+                type: "to-do",
+                operation: "update",
+                id: params.uuid,
+                attributes: {
+                    "checklist-items": specs.map((s) => ({
+                        type: "checklist-item",
+                        attributes: { title: s.title, completed: s.completed },
+                    })),
+                },
+            },
+        ]);
+        return thingsUrl("json", { data: payload }, ctx.token);
+    },
+};
+const todoDelete = {
+    op: "todo.delete",
+    hazards: ["H-UNKNOWN-DESTINATION", "H-REPEAT-SCHEDULE"],
+    preRead(db, params) {
+        const pre = emptyPreState();
+        pre.target = loadTarget(db, params.uuid);
+        return pre;
+    },
+    expectedDelta(_pre, params) {
+        return { mode: "update", uuid: params.uuid, assert: [{ field: "trashed", equals: true }] };
+    },
+    compile(params, vector) {
+        if (vector !== "applescript")
+            unsupportedVector(this.op, vector);
+        return osa(`delete to do id ${q(params.uuid)}`);
+    },
+};
+const projectAdd = {
+    op: "project.add",
+    hazards: ["H-UNKNOWN-DESTINATION"],
+    preRead(db, params) {
+        const pre = emptyPreState();
+        if (containerGiven(params.area))
+            pre.destArea = resolveArea(db, params.area);
+        return pre;
+    },
+    expectedDelta(pre, params, ctx) {
+        const assert = [];
+        if (params.notes !== undefined)
+            assert.push({ field: "notes", equals: params.notes });
+        if (params.when !== undefined)
+            assert.push(...whenAssertions(params.when, ctx.todayIso));
+        if (params.deadline !== undefined)
+            assert.push({ field: "deadline", equals: params.deadline });
+        const area = pre.destArea?.resolved;
+        if (area !== undefined && area !== null)
+            assert.push({ field: "area.uuid", equals: area.uuid });
+        return {
+            mode: "create",
+            probe: { title: params.title, type: "project", sinceEpoch: ctx.nowEpoch - 2 },
+            assert,
+        };
+    },
+    compile(params, vector, pre, ctx) {
+        if (vector !== "url-scheme")
+            unsupportedVector(this.op, vector);
+        return thingsUrl("add-project", {
+            title: params.title,
+            notes: params.notes,
+            when: params.when,
+            deadline: params.deadline,
+            "area-id": pre.destArea?.resolved?.uuid,
+            "to-dos": params.todos?.join("\n"),
+        }, ctx.token);
+    },
+};
+const projectUpdate = {
+    op: "project.update",
+    hazards: ["H-UNKNOWN-DESTINATION", "H-REPEAT-SCHEDULE", "H-REMINDER-SCOPE"],
+    preRead(db, params) {
+        assertNotesModesExclusive(params);
+        const pre = emptyPreState();
+        pre.target = loadTarget(db, params.uuid);
+        return pre;
+    },
+    expectedDelta(pre, params, ctx) {
+        const assert = [];
+        if (params.title !== undefined)
+            assert.push({ field: "title", equals: params.title });
+        if (params.notes !== undefined)
+            assert.push({ field: "notes", equals: params.notes });
+        const joined = expectedNotes(pre, params);
+        if (joined !== undefined)
+            assert.push({ field: "notes", equals: joined });
+        if (params.when !== undefined) {
+            assert.push(...whenAssertions(params.when, ctx.todayIso));
+            // 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);
+            assert.push({
+                field: "reminder",
+                equals: reminder === null ? null : normalizeReminder(reminder),
+            });
+        }
+        if (params.deadline !== undefined)
+            assert.push({ field: "deadline", equals: params.deadline });
+        return { mode: "update", uuid: params.uuid, assert };
+    },
+    compile(params, vector, pre, ctx) {
+        if (vector !== "url-scheme")
+            unsupportedVector(this.op, vector);
+        return thingsUrl("update-project", {
+            id: params.uuid,
+            title: params.title,
+            notes: params.notes,
+            "append-notes": params.appendNotes,
+            "prepend-notes": params.prependNotes,
+            when: params.when === undefined
+                ? undefined
+                : whenWithReminder(params.when, effectiveReminder(pre, params)),
+            deadline: params.deadline === null ? "" : params.deadline,
+        }, ctx.token);
+    },
+};
+const projectSetTags = {
+    op: "project.set-tags",
+    hazards: ["H-UNKNOWN-DESTINATION", "H-UNKNOWN-TAG"],
+    preRead(db, params) {
+        const pre = emptyPreState();
+        pre.target = loadTarget(db, params.uuid);
+        pre.missingTags = missingTagTitles(db, params.tags);
+        return pre;
+    },
+    expectedDelta(_pre, params) {
+        return {
+            mode: "update",
+            uuid: params.uuid,
+            assert: [{ field: "tags", equals: sortedTags(params.tags) }],
+        };
+    },
+    compile(params, vector, _pre, ctx) {
+        // Both vectors validated on projects (A1 URL, A2 AppleScript). Full
+        // replacement semantics mirror todo.set-tags; unknown tags are guarded
+        // pre-write (the app silently drops them).
+        if (vector === "url-scheme") {
+            return thingsUrl("update-project", { id: params.uuid, tags: params.tags.join(",") }, ctx.token);
+        }
+        return osa(`set tag names of project id ${q(params.uuid)} to ${q(params.tags.join(", "))}`);
+    },
+};
+const projectMove = {
+    op: "project.move",
+    hazards: ["H-UNKNOWN-DESTINATION", "H-REPEAT-SCHEDULE"],
+    preRead(db, params) {
+        if ((params.detach === true) === containerGiven(params.area)) {
+            throw new RangeError("project.move needs exactly one of area / detach");
+        }
+        const pre = emptyPreState();
+        pre.target = loadTarget(db, params.uuid);
+        if (containerGiven(params.area))
+            pre.destArea = resolveArea(db, params.area);
+        return pre;
+    },
+    expectedDelta(pre, params) {
+        // Area (re/un-)assignment only (E14/P23/P24): status/start/schedule
+        // untouched by the app — the delta pins the new area link.
+        return {
+            mode: "update",
+            uuid: params.uuid,
+            assert: [
+                params.detach === true
+                    ? { field: "area", equals: null }
+                    : { field: "area.uuid", equals: pre.destArea?.resolved?.uuid ?? "" },
+            ],
+        };
+    },
+    compile(params, vector, pre, ctx) {
+        if (vector === "url-scheme") {
+            // P23 (move) / P24 (empty area-id = detach — URL is the ONLY detach
+            // surface: AppleScript rejects missing value/"" and json-null no-ops).
+            return thingsUrl("update-project", {
+                id: params.uuid,
+                "area-id": params.detach === true ? "" : (pre.destArea?.resolved?.uuid ?? ""),
+            }, ctx.token);
+        }
+        if (params.detach === true)
+            unsupportedVector(this.op, vector);
+        return osa(`set area of project id ${q(params.uuid)} to area id ` +
+            q(pre.destArea?.resolved?.uuid ?? ""));
+    },
+};
+const todoRestore = {
+    op: "todo.restore",
+    hazards: ["H-UNKNOWN-DESTINATION", "H-REPEAT-SCHEDULE"],
+    preRead(db, params) {
+        const pre = emptyPreState();
+        pre.target = loadTarget(db, params.uuid);
+        return pre;
+    },
+    expectedDelta(_pre, params) {
+        // The UI's "Put Back", scripted (E15): the item un-trashes into the
+        // Inbox, de-scheduled. Prior list/schedule are NOT restored.
+        return {
+            mode: "update",
+            uuid: params.uuid,
+            assert: [
+                { field: "trashed", equals: false },
+                { field: "start", equals: "inbox" },
+            ],
+        };
+    },
+    compile(params, vector) {
+        if (vector !== "applescript")
+            unsupportedVector(this.op, vector);
+        return osa(`move to do id ${q(params.uuid)} to list "Inbox"`);
+    },
+};
+const projectDuplicate = {
+    op: "project.duplicate",
+    hazards: ["H-UNKNOWN-DESTINATION", "H-REPEAT-SCHEDULE"],
+    preRead(db, params) {
+        const pre = emptyPreState();
+        pre.target = loadTarget(db, params.uuid);
+        return pre;
+    },
+    expectedDelta(pre, _params, ctx) {
+        // E17: the copy carries the title, notes AND children; discover it with
+        // the create probe (fresh creationDate, same as the to-do path E07).
+        const target = pre.target;
+        const title = target !== null && target.type !== "heading" ? target.title : "";
+        const notes = target !== null && target.type !== "heading" ? target.notes : "";
+        return {
+            mode: "create",
+            probe: { title, type: "project", sinceEpoch: ctx.nowEpoch - 2 },
+            assert: [{ field: "notes", equals: notes }],
+        };
+    },
+    compile(params, vector, _pre, ctx) {
+        if (vector !== "url-scheme")
+            unsupportedVector(this.op, vector);
+        return thingsUrl("update-project", { id: params.uuid, duplicate: "true" }, ctx.token);
+    },
+};
+const projectComplete = {
+    op: "project.complete",
+    hazards: ["H-UNKNOWN-DESTINATION", "H-PROJECT-COMPLETE-CHILDREN"],
+    preRead(db, params) {
+        const pre = emptyPreState();
+        pre.target = loadTarget(db, params.uuid);
+        if (pre.target !== null && pre.target.type === "project") {
+            const children = projectChildren(db, params.uuid);
+            pre.openChildren = children.filter((c) => c.status === "open");
+            pre.canceledChildren = children.filter((c) => c.status === "canceled");
+        }
+        return pre;
+    },
+    expectedDelta(pre, params) {
+        // Cascade semantics validated by T08/U08: open children auto-complete,
+        // canceled children stay canceled — verified, not assumed.
+        const cascade = [
+            ...pre.openChildren.map((c) => ({
+                uuid: c.uuid,
+                assert: [{ field: "status", equals: "completed" }],
+            })),
+            ...pre.canceledChildren.map((c) => ({
+                uuid: c.uuid,
+                assert: [{ field: "status", equals: "canceled" }],
+            })),
+        ];
+        return {
+            mode: "state",
+            uuid: params.uuid,
+            assert: [{ field: "status", equals: "completed" }],
+            ...(cascade.length > 0 && { cascade }),
+        };
+    },
+    compile(params, vector, _pre, ctx) {
+        if (vector !== "url-scheme")
+            unsupportedVector(this.op, vector);
+        return thingsUrl("update-project", { id: params.uuid, completed: "true" }, ctx.token);
+    },
+};
+const projectCancel = {
+    op: "project.cancel",
+    hazards: ["H-UNKNOWN-DESTINATION", "H-PROJECT-COMPLETE-CHILDREN"],
+    preRead(db, params) {
+        const pre = emptyPreState();
+        pre.target = loadTarget(db, params.uuid);
+        if (pre.target !== null && pre.target.type === "project") {
+            const children = projectChildren(db, params.uuid);
+            pre.openChildren = children.filter((c) => c.status === "open");
+            pre.completedChildren = children.filter((c) => c.status === "completed");
+        }
+        return pre;
+    },
+    expectedDelta(pre, params) {
+        // Cancel cascade validated by P01: open children auto-cancel, completed
+        // children keep their status AND stopDate — verified, not assumed.
+        const cascade = [
+            ...pre.openChildren.map((c) => ({
+                uuid: c.uuid,
+                assert: [{ field: "status", equals: "canceled" }],
+            })),
+            ...pre.completedChildren.map((c) => ({
+                uuid: c.uuid,
+                assert: [{ field: "status", equals: "completed" }],
+            })),
+        ];
+        return {
+            mode: "state",
+            uuid: params.uuid,
+            assert: [{ field: "status", equals: "canceled" }],
+            ...(cascade.length > 0 && { cascade }),
+        };
+    },
+    compile(params, vector, _pre, ctx) {
+        if (vector !== "url-scheme")
+            unsupportedVector(this.op, vector);
+        return thingsUrl("update-project", { id: params.uuid, canceled: "true" }, ctx.token);
+    },
+};
+const projectReopen = {
+    op: "project.reopen",
+    hazards: ["H-UNKNOWN-DESTINATION"],
+    preRead(db, params) {
+        const pre = emptyPreState();
+        pre.target = loadTarget(db, params.uuid);
+        return pre;
+    },
+    expectedDelta(_pre, params) {
+        // Reopens ONLY the project row (P02/P05): cascade-resolved children
+        // stay resolved — restoring them is a separate, explicit concern
+        // (client restoreChildren / undo's audit-exact replay).
+        return { mode: "state", uuid: params.uuid, assert: [{ field: "status", equals: "open" }] };
+    },
+    compile(params, vector, pre, ctx) {
+        if (vector !== "url-scheme")
+            unsupportedVector(this.op, vector);
+        // The pre status picks the parameter: completed=false vs canceled=false
+        // (each only reverses its own status — P02/P05).
+        const wasCanceled = pre.target !== null && pre.target.type !== "heading" && pre.target.status === "canceled";
+        return thingsUrl("update-project", { id: params.uuid, ...(wasCanceled ? { canceled: "false" } : { completed: "false" }) }, ctx.token);
+    },
+};
+const projectRestore = {
+    op: "project.restore",
+    hazards: ["H-UNKNOWN-DESTINATION"],
+    preRead(db, params) {
+        const pre = emptyPreState();
+        pre.target = loadTarget(db, params.uuid);
+        return pre;
+    },
+    expectedDelta(_pre, params) {
+        // P06: the Anytime list-move on a trashed project flips trashed IN
+        // PLACE — schedule, area link, and children all keep their state
+        // (better than the to-do restore, which relocates to the Inbox).
+        return { mode: "update", uuid: params.uuid, assert: [{ field: "trashed", equals: false }] };
+    },
+    compile(params, vector) {
+        if (vector !== "applescript")
+            unsupportedVector(this.op, vector);
+        return osa(`move project id ${q(params.uuid)} to list "Anytime"`);
+    },
+};
+const projectDelete = {
+    op: "project.delete",
+    hazards: ["H-UNKNOWN-DESTINATION", "H-REPEAT-SCHEDULE"],
+    preRead(db, params) {
+        const pre = emptyPreState();
+        pre.target = loadTarget(db, params.uuid);
+        return pre;
+    },
+    expectedDelta(_pre, params) {
+        // Shallow by design (A24B): only the project row flips trashed=1;
+        // children keep their links (derived Trash membership).
+        return { mode: "update", uuid: params.uuid, assert: [{ field: "trashed", equals: true }] };
+    },
+    compile(params, vector) {
+        if (vector !== "applescript")
+            unsupportedVector(this.op, vector);
+        return osa(`delete project id ${q(params.uuid)}`);
+    },
+};
+const areaAdd = {
+    op: "area.add",
+    hazards: ["H-UNKNOWN-TAG"],
+    preRead(db, params) {
+        const pre = emptyPreState();
+        if (params.tags !== undefined)
+            pre.missingTags = missingTagTitles(db, params.tags);
+        pre.existingEntityUuids = db.prepare("SELECT uuid FROM TMArea WHERE title = ? COLLATE NOCASE").all(params.title).map((r) => r.uuid);
+        return pre;
+    },
+    expectedDelta(pre, params) {
+        return {
+            mode: "entity-created",
+            entity: "area",
+            title: params.title,
+            excludeUuids: pre.existingEntityUuids,
+        };
+    },
+    compile(params, vector) {
+        if (vector !== "applescript")
+            unsupportedVector(this.op, vector);
+        const make = `make new area with properties {name:${q(params.title)}}`;
+        if (params.tags === undefined || params.tags.length === 0)
+            return osa(make);
+        const payload = `tell application "Things3"\n` +
+            `  ${make}\n` +
+            `  set tag names of area ${q(params.title)} to ${q(params.tags.join(", "))}\n` +
+            `end tell`;
+        return { vector: "applescript", kind: "osascript", payload, redactedPayload: payload };
+    },
+};
+const areaDelete = {
+    op: "area.delete",
+    hazards: ["H-UNKNOWN-DESTINATION", "H-PERMANENT-DELETE"],
+    preRead(db, params) {
+        const pre = emptyPreState();
+        pre.entityTarget = resolveArea(db, { title: params.target, uuid: params.target });
+        return pre;
+    },
+    expectedDelta(pre) {
+        const uuid = pre.entityTarget?.resolved?.uuid ?? "";
+        return { mode: "gone", entity: "area", uuid };
+    },
+    compile(_params, vector, pre) {
+        if (vector !== "applescript")
+            unsupportedVector(this.op, vector);
+        return osa(`delete area id ${q(pre.entityTarget?.resolved?.uuid ?? "")}`);
+    },
+};
+const tagAdd = {
+    op: "tag.add",
+    hazards: ["H-UNKNOWN-TAG"],
+    preRead(db, params) {
+        const pre = emptyPreState();
+        if (params.parent !== undefined) {
+            pre.parentTag = resolveTag(db, params.parent);
+            if (pre.parentTag.resolved === null)
+                pre.missingTags = [params.parent];
+        }
+        pre.existingEntityUuids = db.prepare("SELECT uuid FROM TMTag WHERE title = ? COLLATE NOCASE").all(params.title).map((r) => r.uuid);
+        return pre;
+    },
+    expectedDelta(pre, params) {
+        return {
+            mode: "entity-created",
+            entity: "tag",
+            title: params.title,
+            excludeUuids: pre.existingEntityUuids,
+            parentUuid: pre.parentTag?.resolved?.uuid ?? null,
+        };
+    },
+    compile(params, vector, pre) {
+        if (vector !== "applescript")
+            unsupportedVector(this.op, vector);
+        const make = `make new tag with properties {name:${q(params.title)}}`;
+        const parent = pre.parentTag?.resolved;
+        if (parent === undefined || parent === null)
+            return osa(make);
+        const payload = `tell application "Things3"\n` +
+            `  ${make}\n` +
+            `  set parent tag of tag ${q(params.title)} to tag ${q(parent.title)}\n` +
+            `end tell`;
+        return { vector: "applescript", kind: "osascript", payload, redactedPayload: payload };
+    },
+};
+const tagDelete = {
+    op: "tag.delete",
+    hazards: ["H-UNKNOWN-DESTINATION", "H-PERMANENT-DELETE", "H-TAG-SUBTREE-DELETE"],
+    preRead(db, params) {
+        const pre = emptyPreState();
+        pre.entityTarget = resolveTag(db, params.target);
+        if (pre.entityTarget.resolved !== null) {
+            pre.childTags = childTagTitles(db, pre.entityTarget.resolved.uuid);
+        }
+        return pre;
+    },
+    expectedDelta(pre) {
+        return { mode: "gone", entity: "tag", uuid: pre.entityTarget?.resolved?.uuid ?? "" };
+    },
+    compile(_params, vector, pre) {
+        if (vector !== "applescript")
+            unsupportedVector(this.op, vector);
+        return osa(`delete tag id ${q(pre.entityTarget?.resolved?.uuid ?? "")}`);
+    },
+};
+const todoDuplicate = {
+    op: "todo.duplicate",
+    hazards: ["H-UNKNOWN-DESTINATION", "H-REPEAT-SCHEDULE"],
+    preRead(db, params) {
+        const pre = emptyPreState();
+        pre.target = loadTarget(db, params.uuid);
+        return pre;
+    },
+    expectedDelta(pre, _params, ctx) {
+        // The copy carries the same title/notes with a fresh uuid + creationDate
+        // (E07) — discover it with the create probe, assert copy fidelity.
+        const target = pre.target;
+        const title = target !== null && target.type !== "heading" ? target.title : "";
+        const notes = target !== null && target.type !== "heading" ? target.notes : "";
+        return {
+            mode: "create",
+            probe: { title, type: "to-do", sinceEpoch: ctx.nowEpoch - 2 },
+            assert: [{ field: "notes", equals: notes }],
+        };
+    },
+    compile(params, vector, _pre, ctx) {
+        // AppleScript refuses duplication outright ("can not be copied", E08).
+        if (vector !== "url-scheme")
+            unsupportedVector(this.op, vector);
+        return thingsUrl("update", { id: params.uuid, duplicate: "true" }, ctx.token);
+    },
+};
+const areaUpdate = {
+    op: "area.update",
+    hazards: ["H-UNKNOWN-DESTINATION", "H-UNKNOWN-TAG"],
+    preRead(db, params) {
+        if (params.title === undefined && params.tags === undefined) {
+            throw new RangeError("area.update needs title and/or tags");
+        }
+        const pre = emptyPreState();
+        pre.entityTarget = resolveArea(db, { title: params.target, uuid: params.target });
+        if (params.tags !== undefined)
+            pre.missingTags = missingTagTitles(db, params.tags);
+        return pre;
+    },
+    expectedDelta(pre, params) {
+        const assert = [];
+        if (params.title !== undefined)
+            assert.push({ field: "title", equals: params.title });
+        if (params.tags !== undefined)
+            assert.push({ field: "tags", equals: sortedTags(params.tags) });
+        return {
+            mode: "entity-updated",
+            entity: "area",
+            uuid: pre.entityTarget?.resolved?.uuid ?? "",
+            assert,
+        };
+    },
+    compile(params, vector, pre) {
+        if (vector !== "applescript")
+            unsupportedVector(this.op, vector);
+        const id = q(pre.entityTarget?.resolved?.uuid ?? "");
+        const lines = [];
+        if (params.title !== undefined)
+            lines.push(`set name of area id ${id} to ${q(params.title)}`);
+        if (params.tags !== undefined) {
+            lines.push(`set tag names of area id ${id} to ${q(params.tags.join(", "))}`);
+        }
+        if (lines.length === 1)
+            return osa(lines[0]);
+        const payload = `tell application "Things3"\n${lines.map((l) => `  ${l}`).join("\n")}\nend tell`;
+        return { vector: "applescript", kind: "osascript", payload, redactedPayload: payload };
+    },
+};
+const tagUpdate = {
+    op: "tag.update",
+    hazards: ["H-UNKNOWN-DESTINATION", "H-UNKNOWN-TAG"],
+    preRead(db, params) {
+        if (params.title === undefined &&
+            params.parent === undefined &&
+            params.unnest === undefined &&
+            params.shortcut === undefined &&
+            params.clearShortcut === undefined) {
+            throw new RangeError("tag.update needs title, parent, unnest, shortcut, and/or clearShortcut");
+        }
+        if (params.parent !== undefined && params.unnest === true) {
+            throw new RangeError("parent and unnest are exclusive");
+        }
+        if (params.shortcut !== undefined && params.clearShortcut === true) {
+            throw new RangeError("shortcut and clearShortcut are exclusive");
+        }
+        const pre = emptyPreState();
+        pre.entityTarget = resolveTag(db, params.target);
+        if (params.parent !== undefined) {
+            pre.parentTag = resolveTag(db, params.parent);
+            if (pre.parentTag.resolved === null)
+                pre.missingTags = [params.parent];
+        }
+        return pre;
+    },
+    expectedDelta(pre, params) {
+        const assert = [];
+        if (params.title !== undefined)
+            assert.push({ field: "title", equals: params.title });
+        if (params.parent !== undefined) {
+            assert.push({ field: "parent", equals: pre.parentTag?.resolved?.uuid ?? "" });
+        }
+        if (params.unnest === true)
+            assert.push({ field: "parent", equals: null });
+        if (params.shortcut !== undefined)
+            assert.push({ field: "shortcut", equals: params.shortcut });
+        if (params.clearShortcut === true)
+            assert.push({ field: "shortcut", equals: null });
+        return {
+            mode: "entity-updated",
+            entity: "tag",
+            uuid: pre.entityTarget?.resolved?.uuid ?? "",
+            assert,
+        };
+    },
+    compile(params, vector, pre) {
+        if (vector !== "applescript")
+            unsupportedVector(this.op, vector);
+        const id = q(pre.entityTarget?.resolved?.uuid ?? "");
+        const lines = [];
+        if (params.title !== undefined)
+            lines.push(`set name of tag id ${id} to ${q(params.title)}`);
+        if (params.parent !== undefined) {
+            lines.push(`set parent tag of tag id ${id} to tag id ${q(pre.parentTag?.resolved?.uuid ?? "")}`);
+        }
+        if (params.unnest === true) {
+            // The property-DELETE form is the only working un-nest spelling (P29):
+            // `set parent tag … to missing value` errors (E19). By NAME, exactly
+            // as probed — resolveTag already guaranteed the title is unique.
+            lines.push(`delete parent tag of tag ${q(pre.entityTarget?.resolved?.title ?? "")}`);
+        }
+        if (params.shortcut !== undefined) {
+            lines.push(`set keyboard shortcut of tag id ${id} to ${q(params.shortcut)}`);
+        }
+        if (params.clearShortcut === true) {
+            // The property-DELETE form clears the shortcut (A4 — the P29 un-nest
+            // spelling generalizes to `shortcut`; `set … to ""`/missing value has
+            // no validated clear path). By NAME, exactly as probed.
+            lines.push(`delete keyboard shortcut of tag ${q(pre.entityTarget?.resolved?.title ?? "")}`);
+        }
+        if (lines.length === 1)
+            return osa(lines[0]);
+        const payload = `tell application "Things3"\n${lines.map((l) => `  ${l}`).join("\n")}\nend tell`;
+        return { vector: "applescript", kind: "osascript", payload, redactedPayload: payload };
+    },
+};
+const reorder = {
+    op: "reorder",
+    hazards: ["H-UNKNOWN-DESTINATION", "H-REORDER-SCOPE"],
+    preRead(db, params, now) {
+        const pre = emptyPreState();
+        let containerUuid = null;
+        if (params.scope === "project" || params.scope === "headings") {
+            pre.destProject = resolveProject(db, params.container ?? {});
+            containerUuid = pre.destProject.resolved?.uuid ?? null;
+        }
+        if (params.scope === "area") {
+            pre.destArea = resolveArea(db, params.container ?? {});
+            containerUuid = pre.destArea.resolved?.uuid ?? null;
+        }
+        pre.reorder = computeReorderPre(db, params, containerUuid, now);
+        return pre;
+    },
+    expectedDelta(pre, params) {
+        // 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.
+        return {
+            mode: "ordering",
+            key: pre.reorder?.key ??
+                (params.scope === "today" || params.scope === "evening" ? "todayIndex" : "index"),
+            sequence: params.uuids,
+        };
+    },
+    compile(params, vector, pre) {
+        if (vector !== "applescript")
+            unsupportedVector(this.op, vector);
+        const specifier = params.scope === "project" || params.scope === "headings"
+            ? `project id ${q(pre.destProject?.resolved?.uuid ?? "")}`
+            : params.scope === "area"
+                ? `area id ${q(pre.destArea?.resolved?.uuid ?? "")}`
+                : params.scope === "inbox"
+                    ? `list "Inbox"`
+                    : params.scope === "someday"
+                        ? `list "Someday"`
+                        : `list "Today"`;
+        const wire = 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) — P6h/P7e/P8b. The validated
+            // two-call protocol realizes an exact order: (1) push the desired
+            // BOTTOM item to the top, making it the anchor; (2) send the reversed
+            // wire list — the anchor (first id) stays put and the rest stack above
+            // it in desired order (P8b: exact).
+            const bottom = wire.at(-1) ?? "";
+            const reversed = wire.toReversed().join(",");
+            return osaBlock([
+                `${PRIVATE_REORDER_COMMAND} ${specifier} with ids ${q(bottom)}`,
+                `${PRIVATE_REORDER_COMMAND} ${specifier} with ids ${q(reversed)}`,
+            ]);
+        }
+        return osa(`${PRIVATE_REORDER_COMMAND} ${specifier} with ids ${q(wire.join(","))}`);
+    },
+};
+/** Locale-proof AppleScript date literal: local noon on an ISO date. */
+function asDateBlock(varName, iso) {
+    const [y, m, d] = iso.split("-").map(Number);
+    return [
+        `set ${varName} to current date`,
+        `set time of ${varName} to 12 * hours`,
+        `set day of ${varName} to 1`,
+        `set year of ${varName} to ${y}`,
+        `set month of ${varName} to ${m}`,
+        `set day of ${varName} to ${d}`,
+    ];
+}
+const todoBackdate = {
+    op: "todo.backdate",
+    hazards: ["H-BACKDATE-OPEN"],
+    preRead(db, params) {
+        if (params.completionDate === undefined && params.creationDate === undefined) {
+            throw new RangeError("nothing to backdate: give completionDate and/or creationDate");
+        }
+        const pre = emptyPreState();
+        pre.target = loadTarget(db, params.uuid);
+        return pre;
+    },
+    expectedDelta(_pre, params) {
+        const assert = [];
+        if (params.completionDate !== undefined) {
+            assert.push({ field: "stoppedDate", equals: params.completionDate });
+        }
+        if (params.creationDate !== undefined) {
+            assert.push({ field: "createdDate", equals: params.creationDate });
+        }
+        return { mode: "update", uuid: params.uuid, assert };
+    },
+    compile(params, vector) {
+        if (vector !== "applescript")
+            unsupportedVector(this.op, vector);
+        const statements = [];
+        if (params.completionDate !== undefined) {
+            statements.push(...asDateBlock("compDate", params.completionDate), `set completion date of to do id ${q(params.uuid)} to compDate`);
+        }
+        if (params.creationDate !== undefined) {
+            statements.push(...asDateBlock("createDate", params.creationDate), `set creation date of to do id ${q(params.uuid)} to createDate`);
+        }
+        return osaBlock(statements);
+    },
+};
+const todoAddLogged = {
+    op: "todo.add-logged",
+    hazards: [],
+    preRead(db, params) {
+        if (params.creationDate !== undefined &&
+            params.creationDate.localeCompare(params.completionDate) > 0) {
+            throw new RangeError("creationDate must not be after completionDate");
+        }
+        const pre = emptyPreState();
+        pre.sameTitleUuids = db.prepare("SELECT uuid FROM TMTask WHERE title = ? AND type = 0").all(params.title).map((r) => r.uuid);
+        return pre;
+    },
+    expectedDelta(pre, params) {
+        const assert = [
+            { field: "status", equals: "completed" },
+            { field: "stoppedDate", equals: params.completionDate },
+        ];
+        if (params.creationDate !== undefined) {
+            assert.push({ field: "createdDate", equals: params.creationDate });
+        }
+        if (params.notes !== undefined)
+            assert.push({ field: "notes", equals: params.notes });
+        return {
+            mode: "create",
+            probe: {
+                title: params.title,
+                type: "to-do",
+                sinceEpoch: 0,
+                excludeUuids: pre.sameTitleUuids,
+            },
+            assert,
+        };
+    },
+    compile(params, vector, _pre, ctx) {
+        if (vector !== "url-scheme")
+            unsupportedVector(this.op, vector);
+        // Local noon -> UTC instant, so the stored timestamp decodes back to the
+        // requested local DATE in every timezone (P4d: json attrs honored exactly).
+        const utcNoon = (iso) => {
+            const [y, m, d] = iso.split("-").map(Number);
+            return new Date(y ?? 0, (m ?? 1) - 1, d ?? 1, 12, 0, 0).toISOString();
+        };
+        const payload = JSON.stringify([
+            {
+                type: "to-do",
+                attributes: {
+                    title: params.title,
+                    ...(params.notes !== undefined && { notes: params.notes }),
+                    completed: true,
+                    "completion-date": utcNoon(params.completionDate),
+                    ...(params.creationDate !== undefined && {
+                        "creation-date": utcNoon(params.creationDate),
+                    }),
+                },
+            },
+        ]);
+        return thingsUrl("json", { data: payload }, ctx.token);
+    },
+};
+const trashEmpty = {
+    op: "trash.empty",
+    hazards: ["H-PERMANENT-DELETE"],
+    preRead(db) {
+        const pre = emptyPreState();
+        pre.trashedCount = trashedCount(db);
+        return pre;
+    },
+    expectedDelta() {
+        return { mode: "trash-emptied" };
+    },
+    compile(_params, vector) {
+        if (vector !== "applescript")
+            unsupportedVector(this.op, vector);
+        return osa("empty trash");
+    },
+};
+export const COMMANDS = {
+    "todo.add": todoAdd,
+    "todo.update": todoUpdate,
+    "todo.complete": todoComplete,
+    "todo.cancel": todoCancel,
+    "todo.reopen": todoReopen,
+    "todo.move": todoMove,
+    "todo.set-tags": todoSetTags,
+    "todo.replace-checklist": todoReplaceChecklist,
+    "todo.delete": todoDelete,
+    "project.add": projectAdd,
+    "project.update": projectUpdate,
+    "project.complete": projectComplete,
+    "project.delete": projectDelete,
+    "area.add": areaAdd,
+    "area.delete": areaDelete,
+    "tag.add": tagAdd,
+    "tag.delete": tagDelete,
+    "trash.empty": trashEmpty,
+    reorder,
+    "todo.duplicate": todoDuplicate,
+    "area.update": areaUpdate,
+    "tag.update": tagUpdate,
+    "project.move": projectMove,
+    "todo.restore": todoRestore,
+    "project.duplicate": projectDuplicate,
+    "project.cancel": projectCancel,
+    "project.reopen": projectReopen,
+    "project.restore": projectRestore,
+    "project.set-tags": projectSetTags,
+    "todo.backdate": todoBackdate,
+    "todo.add-logged": todoAddLogged,
+};
+//# sourceMappingURL=commands.js.map