things-api 0.17.0 → 0.19.0

package/dist/write/template-mutation.d.ts

@@ -0,0 +1,137 @@
+/**
+ * Template-mutation composites — "Create Next Copy, then mutate the instance"
+ * (design of record: docs/lab/cnc1-template-mutations.md; ruling 2026-08-24).
+ *
+ * A repeating template refuses every schedule/status write we ship, and the
+ * app's own Make Exception chooser is not on the automation path. CNC1 measured
+ * the alternative and it is exact: `Items ▸ Repeat ▸ Create Next Copy` followed
+ * by an ordinary write to the row it mints reproduces Make Exception FIELD FOR
+ * FIELD on the template (weekly against REPX3 §1.2, daily against §2.1; the
+ * vacated slot then stays silent when the clock reaches it, against a live
+ * control that spawns normally). The composite differs from the chooser by one
+ * column on one row — the minted instance's modification stamp, which the
+ * chooser leaves unset — and that difference is the winning side of Things
+ * Cloud's merge arbitration (SYNCX1), so it is the safe direction.
+ *
+ * Two composites live here:
+ *
+ *   - {@link runTemplateStatusWrite} — `complete`/`cancel` aimed at a series.
+ *     UNFLAGGED, because there is exactly one sane reading of "check off this
+ *     repeating to-do". If the series already has an OPEN materialized
+ *     occurrence, that IS the current one and it is resolved directly (no
+ *     mint); otherwise the pending occurrence is materialized first and
+ *     resolved. Either way the template is left byte-unchanged and the series
+ *     continues on schedule (CNC1 §6, measured for `cancel` as well as
+ *     `complete`).
+ *
+ *   - {@link runTemplateExceptionWrite} — `update --exception` aimed at a
+ *     series: move/re-deadline/re-remind ONLY the next occurrence. Always mints,
+ *     because the exception semantics belong to the PENDING occurrence — the one
+ *     the rule has not spawned yet. (Re-dating an already-materialized
+ *     occurrence is an ordinary update on that row and consumes no slot, so the
+ *     rule would still spawn its own copy — REPX1 §3.2. Callers who want that
+ *     can address the occurrence directly.)
+ *
+ * Three refusals, each measured, are enforced before anything is driven:
+ *
+ *   1. a target date that is a live slot of the same rule DOUBLE-BOOKS that day
+ *      (CNC1 §2, inheriting oddities §17 whole);
+ *   2. a series with NO CURSOR has no pending occurrence to materialize, and
+ *      `Create Next Copy` duplicates the current one onto the same day instead
+ *      (CNC1 §5, CNCAC1 §6/§8, oddities §18);
+ *   3. repeating PROJECTS are out of scope: the menu that carries the command
+ *      does not exist for a project selection (CNC1 §8).
+ *
+ * Refusal 2 used to be keyed on the rule KIND — "after-completion" — and that
+ * was fail-closed guesswork that fired on the wrong state. CNCAC1 measured the
+ * shape it was actually hitting: an after-completion series ANCHORS on its
+ * occurrence being resolved and DERIVES a real cursor from that anchor, so a
+ * series with a completed history renders a projection in Upcoming, the GUI
+ * checks that projection off, and `Create Next Copy` materializes it correctly
+ * with no duplicate — byte-equivalent to the GUI gesture modulo the minted row's
+ * modification stamp. The duplicate belongs to the CURSOR-LESS case alone (a
+ * never-resolved series, or a paused one), which is what this now refuses.
+ *
+ * Reversibility is HALF and is disclosed at op time: `things undo` restores the
+ * occurrence's own change perfectly, and can neither remove the materialized
+ * occurrence nor rewind the series (CNC1 §7).
+ *
+ * Two contract facts hold for BOTH composites (ruling 2026-08-25):
+ *
+ *   - The result NAMES THE OCCURRENCE. Every success carries an
+ *     {@link OccurrenceResolution}: the template the caller aimed at, the
+ *     occurrence that was actually written, and whether that occurrence was
+ *     minted for this call or already existed. The caller never has to infer
+ *     which row moved — the same courtesy `add-repeating` does with its
+ *     template/instance pair.
+ *
+ *   - The composite is ONE op for idempotency. It records a single summary
+ *     record (the legs stay legs, and the caller's `opId` rides the summary
+ *     alone), so a caller that retries after an ambiguous failure — a killed
+ *     process, a timed-out agent — replays the recorded result instead of
+ *     minting a SECOND occurrence and advancing the series a second time. Every
+ *     re-run without a key is a genuinely new action, which is exactly the
+ *     add-repeating hazard class: pass `--op-id` on a retry.
+ */
+import { type IsoDate } from "../model/dates.ts";
+import type { RepeatRule } from "../model/recurrence.ts";
+import type { UpdateFields } from "./operations.ts";
+import { type MutationResult, type WriteDeps, type WriteOptions } from "./pipeline.ts";
+declare const PROJECT_REFUSAL = "this is a repeating project, and only repeating to-dos can have a single occurrence changed";
+declare const PROJECT_REMEDIATION: string;
+/** What the composite learned about the series before it drove anything. */
+interface SeriesState {
+    templateUuid: string;
+    title: string;
+    /** The pending occurrence's date — the slot a mint would consume. */
+    cursor: IsoDate | null;
+    rule: RepeatRule | null;
+    deadlined: boolean;
+    afterCompletion: boolean;
+    /** The series is paused, which is WHY it has no cursor — a different remedy. */
+    paused: boolean;
+    /** An already-materialized OPEN occurrence of this series, if there is one. */
+    openInstance: {
+        uuid: string;
+        startDate: IsoDate | null;
+    } | null;
+}
+/**
+ * Read everything the composite decides on, in one pass. Returns null when the
+ * target is not a repeating to-do template, which the caller has already
+ * established but which keeps this total.
+ */
+export declare function readSeriesState(deps: WriteDeps, uuid: string): SeriesState | null;
+/**
+ * The dates this rule will still produce ON ITS OWN after the pending
+ * occurrence has been materialized — i.e. every slot from the one AFTER the
+ * cursor up to and including `until`. Landing an occurrence on one of these
+ * leaves that day holding two copies once the clock reaches it (CNC1 §2), which
+ * is the whole reason this list exists.
+ *
+ * Empty when the rule is undecodable or has no calendar: nothing can be proven
+ * about a rule we cannot read, and the caller refuses rather than guessing.
+ */
+export declare function liveSlotsAfterMint(state: SeriesState, until: IsoDate): IsoDate[];
+/**
+ * `complete`/`cancel` aimed at a repeating to-do. Resolves the series' CURRENT
+ * occurrence: the open materialized one when it exists, otherwise the pending
+ * one, materialized first. The template itself is never written — CNC1 §6
+ * measured both status writes leaving it byte-unchanged, with the series
+ * continuing at its next date and exactly one occurrence per day.
+ */
+export declare function runTemplateStatusWrite(deps: WriteDeps, op: "todo.complete" | "todo.cancel", uuid: string, 
+/**
+ * The status write itself, applied to ONE ordinary occurrence. Injected
+ * rather than imported so the caller keeps ownership of its own vocabulary —
+ * `--completed-at` backdating, the children policy — and so this module does
+ * not have to import the resolution orchestrator that calls it.
+ */
+runStatusLeg: (occurrenceUuid: string, legOptions: WriteOptions) => Promise<MutationResult>, options?: WriteOptions): Promise<MutationResult>;
+/**
+ * `update --exception` aimed at a repeating to-do: change ONLY the next
+ * occurrence. Materializes the pending occurrence and applies the patch to it,
+ * which is what the app's own "make a one-time exception" does.
+ */
+export declare function runTemplateExceptionWrite(deps: WriteDeps, uuid: string, patch: UpdateFields & Record<string, unknown>, options?: WriteOptions): Promise<MutationResult>;
+export { PROJECT_REFUSAL, PROJECT_REMEDIATION };

package/dist/write/template-mutation.js

@@ -0,0 +1,451 @@
+/**
+ * Template-mutation composites — "Create Next Copy, then mutate the instance"
+ * (design of record: docs/lab/cnc1-template-mutations.md; ruling 2026-08-24).
+ *
+ * A repeating template refuses every schedule/status write we ship, and the
+ * app's own Make Exception chooser is not on the automation path. CNC1 measured
+ * the alternative and it is exact: `Items ▸ Repeat ▸ Create Next Copy` followed
+ * by an ordinary write to the row it mints reproduces Make Exception FIELD FOR
+ * FIELD on the template (weekly against REPX3 §1.2, daily against §2.1; the
+ * vacated slot then stays silent when the clock reaches it, against a live
+ * control that spawns normally). The composite differs from the chooser by one
+ * column on one row — the minted instance's modification stamp, which the
+ * chooser leaves unset — and that difference is the winning side of Things
+ * Cloud's merge arbitration (SYNCX1), so it is the safe direction.
+ *
+ * Two composites live here:
+ *
+ *   - {@link runTemplateStatusWrite} — `complete`/`cancel` aimed at a series.
+ *     UNFLAGGED, because there is exactly one sane reading of "check off this
+ *     repeating to-do". If the series already has an OPEN materialized
+ *     occurrence, that IS the current one and it is resolved directly (no
+ *     mint); otherwise the pending occurrence is materialized first and
+ *     resolved. Either way the template is left byte-unchanged and the series
+ *     continues on schedule (CNC1 §6, measured for `cancel` as well as
+ *     `complete`).
+ *
+ *   - {@link runTemplateExceptionWrite} — `update --exception` aimed at a
+ *     series: move/re-deadline/re-remind ONLY the next occurrence. Always mints,
+ *     because the exception semantics belong to the PENDING occurrence — the one
+ *     the rule has not spawned yet. (Re-dating an already-materialized
+ *     occurrence is an ordinary update on that row and consumes no slot, so the
+ *     rule would still spawn its own copy — REPX1 §3.2. Callers who want that
+ *     can address the occurrence directly.)
+ *
+ * Three refusals, each measured, are enforced before anything is driven:
+ *
+ *   1. a target date that is a live slot of the same rule DOUBLE-BOOKS that day
+ *      (CNC1 §2, inheriting oddities §17 whole);
+ *   2. a series with NO CURSOR has no pending occurrence to materialize, and
+ *      `Create Next Copy` duplicates the current one onto the same day instead
+ *      (CNC1 §5, CNCAC1 §6/§8, oddities §18);
+ *   3. repeating PROJECTS are out of scope: the menu that carries the command
+ *      does not exist for a project selection (CNC1 §8).
+ *
+ * Refusal 2 used to be keyed on the rule KIND — "after-completion" — and that
+ * was fail-closed guesswork that fired on the wrong state. CNCAC1 measured the
+ * shape it was actually hitting: an after-completion series ANCHORS on its
+ * occurrence being resolved and DERIVES a real cursor from that anchor, so a
+ * series with a completed history renders a projection in Upcoming, the GUI
+ * checks that projection off, and `Create Next Copy` materializes it correctly
+ * with no duplicate — byte-equivalent to the GUI gesture modulo the minted row's
+ * modification stamp. The duplicate belongs to the CURSOR-LESS case alone (a
+ * never-resolved series, or a paused one), which is what this now refuses.
+ *
+ * Reversibility is HALF and is disclosed at op time: `things undo` restores the
+ * occurrence's own change perfectly, and can neither remove the materialized
+ * occurrence nor rewind the series (CNC1 §7).
+ *
+ * Two contract facts hold for BOTH composites (ruling 2026-08-25):
+ *
+ *   - The result NAMES THE OCCURRENCE. Every success carries an
+ *     {@link OccurrenceResolution}: the template the caller aimed at, the
+ *     occurrence that was actually written, and whether that occurrence was
+ *     minted for this call or already existed. The caller never has to infer
+ *     which row moved — the same courtesy `add-repeating` does with its
+ *     template/instance pair.
+ *
+ *   - The composite is ONE op for idempotency. It records a single summary
+ *     record (the legs stay legs, and the caller's `opId` rides the summary
+ *     alone), so a caller that retries after an ambiguous failure — a killed
+ *     process, a timed-out agent — replays the recorded result instead of
+ *     minting a SECOND occurrence and advancing the series a second time. Every
+ *     re-run without a key is a genuinely new action, which is exactly the
+ *     add-repeating hazard class: pass `--op-id` on a retry.
+ */
+import { addDaysIso, decodePackedDate, localToday } from "../model/dates.js";
+import { projectOccurrences } from "../model/occurrences.js";
+import { byUuid } from "../read/detail.js";
+import { replayIfApplied } from "./opid.js";
+import { appendCompositeSummary, runComposite, runMutation, } from "./pipeline.js";
+/** How far ahead the collision check will look for a live slot. */
+const SLOT_LOOKAHEAD = 400;
+const IRREVERSIBLE_NOTE = "`things undo` restores this occurrence's own change; it cannot remove the occurrence that was " +
+    "created for it, and the series has already moved on to its following date";
+const PROJECT_REFUSAL = "this is a repeating project, and only repeating to-dos can have a single occurrence changed";
+const PROJECT_REMEDIATION = "change the whole series with `things project reschedule-repeat <ref>`, or change one of its " +
+    "to-dos directly";
+/**
+ * The precondition, stated as what it actually is. A composite can only work on
+ * an occurrence the series has NOT spawned yet, and the app tells us whether
+ * there is one: `rt1_nextInstanceStartDate`. When it is null there is no next
+ * date to bring forward, and `Create Next Copy` does not refuse — it DUPLICATES
+ * the current occurrence onto the same day (CNC1 §5 / CNCAC1 §6, oddities §18).
+ *
+ * This replaces a rule-KIND refusal that fired on the wrong state. It read "an
+ * after-completion series has no upcoming occurrence until the current one is
+ * done" — but CNCAC1 measured that an after-completion series acquires a real
+ * cursor the moment its occurrence is resolved (completed, canceled, OR
+ * trashed), which is precisely when the old branch fired: it refused the one
+ * shape whose projection the app renders in Upcoming and happily checks off.
+ *
+ * With that corrected, the only state that reaches this refusal is a PAUSED
+ * series whose occurrence is already resolved — and there the refusal earns its
+ * keep for a second measured reason. CNC on a paused series does not duplicate;
+ * it quietly materializes the occurrence the pause was suppressing, from the
+ * stale anchor, and clears that anchor while leaving the paused flag set
+ * (CNCAC1 §8). Producing an occurrence from a series the user deliberately
+ * paused is not a reading of "check this off" worth guessing at, so the refusal
+ * names `resume-repeat` instead.
+ */
+const NO_PENDING_REFUSAL = "this repeating to-do has no upcoming occurrence to work on — its schedule names no next date, " +
+    "so there is nothing to bring forward";
+function blocked(op, detail, remediation) {
+    return { kind: "blocked", op, reason: "environment", detail, remediation };
+}
+/**
+ * Read everything the composite decides on, in one pass. Returns null when the
+ * target is not a repeating to-do template, which the caller has already
+ * established but which keeps this total.
+ */
+export function readSeriesState(deps, uuid) {
+    const target = byUuid(deps.db, uuid);
+    if (target === null || target.type === "heading" || !target.repeating.isTemplate)
+        return null;
+    const rule = target.repeating.rule ?? null;
+    const rows = deps.db
+        .prepare("SELECT uuid, startDate FROM TMTask WHERE rt1_repeatingTemplate = ? AND trashed = 0 " +
+        "AND status = 0 ORDER BY startDate, creationDate")
+        .all(uuid);
+    const first = rows[0];
+    return {
+        templateUuid: uuid,
+        title: target.title,
+        cursor: target.repeating.nextOccurrence ?? null,
+        rule,
+        deadlined: target.repeating.deadlined === true,
+        afterCompletion: rule !== null && rule.type === "after-completion",
+        paused: target.repeating.paused === true,
+        openInstance: first === undefined
+            ? null
+            : { uuid: first.uuid, startDate: decodePackedDate(first.startDate) },
+    };
+}
+/**
+ * The dates this rule will still produce ON ITS OWN after the pending
+ * occurrence has been materialized — i.e. every slot from the one AFTER the
+ * cursor up to and including `until`. Landing an occurrence on one of these
+ * leaves that day holding two copies once the clock reaches it (CNC1 §2), which
+ * is the whole reason this list exists.
+ *
+ * Empty when the rule is undecodable or has no calendar: nothing can be proven
+ * about a rule we cannot read, and the caller refuses rather than guessing.
+ */
+export function liveSlotsAfterMint(state, until) {
+    const { rule, cursor } = state;
+    if (rule === null || rule.type !== "fixed" || cursor === null)
+        return [];
+    if (until <= cursor)
+        return [];
+    const projected = projectOccurrences(rule, cursor, { count: SLOT_LOOKAHEAD, until }, state.deadlined);
+    // The first projection IS the cursor — the slot the mint consumes, not a
+    // collision. Everything after it is a slot the rule will still fire.
+    return projected.slice(1).map((o) => o.startDate);
+}
+/**
+ * Resolve the calendar day a `when` value lands on, or null when it names no
+ * single day (`anytime`/`someday` are not dated, so they cannot collide with a
+ * slot).
+ */
+function whenTargetDay(when, todayIso) {
+    if (when === undefined)
+        return null;
+    if (when === "today" || when === "evening")
+        return todayIso;
+    if (when === "tomorrow")
+        return addDaysIso(todayIso, 1);
+    return /^\d{4}-\d{2}-\d{2}$/.test(when) ? when : null;
+}
+/**
+ * The refusal for a series with nothing pending, with the remedy that fits WHY
+ * it is empty. A paused series is one command away from having a cursor again;
+ * anything else is the app's own business.
+ */
+function noPendingRefusal(op, state) {
+    if (state.paused) {
+        return blocked(op, "this repeating to-do is paused, so it has no upcoming occurrence to work on", "resume it first with `things todo resume-repeat <ref>`");
+    }
+    return blocked(op, NO_PENDING_REFUSAL, "work on one of its occurrences directly");
+}
+/** Human phrasing for "the occurrence dated X" when X may be unknown. */
+function occurrenceLabel(date) {
+    return date === null ? "the current occurrence" : `the ${date} occurrence`;
+}
+/** Where the series goes next, read back AFTER the composite has run. */
+function nextOccurrenceAfter(deps, templateUuid) {
+    const target = byUuid(deps.db, templateUuid);
+    if (target === null || target.type === "heading")
+        return null;
+    return target.repeating.nextOccurrence ?? null;
+}
+/**
+ * Materialize the pending occurrence and hand back its uuid. Split out because
+ * both composites need exactly this, including the failure phrasing: a mint
+ * that did not land must never be reported as a mutation that did.
+ */
+async function mintPendingOccurrence(deps, op, templateUuid, options, txnId) {
+    const mint = await runMutation(deps, "todo.create-next-copy", { uuid: templateUuid }, {
+        ...legOptions(options, txnId),
+        vector: "ui",
+        // The GUI-drive ACKNOWLEDGEMENT is made here, on the caller's behalf, and
+        // it is the one place in the package that does so. Rationale (ruling
+        // 2026-08-24): these verbs are UNFLAGGED — "check off this repeating
+        // to-do" and "move only the next occurrence" already name the effect the
+        // user asked for, and there is no other way to perform either, so a second
+        // flag would be ceremony with no decision behind it. Nothing else is
+        // relaxed: Article IV's capability gate still refuses a machine whose
+        // helpers have no GUI tier, and the disruption ceiling still refuses
+        // unless the caller allowed a change that visibly drives the app — which
+        // is the control that keeps this from being a surprise.
+        dangerouslyDriveGui: true,
+    });
+    if (mint.kind !== "ok" || mint.uuid === null) {
+        return {
+            ok: false,
+            result: {
+                ...mint,
+                op,
+                ...("detail" in mint
+                    ? { detail: `${mint.detail} — no occurrence was created, so nothing was changed` }
+                    : {}),
+            },
+        };
+    }
+    return { ok: true, uuid: mint.uuid };
+}
+function newTxnId(now) {
+    return `txn-${now.getTime().toString(36)}-${process.pid.toString(36)}`;
+}
+/**
+ * The options a LEG runs under: the caller's, grouped into the composite's txn,
+ * with the idempotency key REMOVED. The key identifies the whole composite, and
+ * the composite records exactly one record for it (the summary) — leaving it on
+ * the legs would put the same key on two or three records and let a resubmission
+ * match half a verb.
+ */
+function legOptions(options, txnId) {
+    const { opId: _opId, ...rest } = options;
+    return { ...rest, txn: { id: txnId, role: "leg" } };
+}
+/**
+ * Record the composite as ONE summary record and hand back its undo token.
+ *
+ * This is the record the whole verb is addressed by: `undo` targets it (a leg is
+ * never a direct undo target, so before this existed the composite left nothing
+ * for `things undo` to reach), and it is the single record the caller's `opId`
+ * keys, carrying the occurrence pair so a replay can answer with it.
+ *
+ * The summary's vector/tier report the composite's MOST disruptive leg: a mint
+ * drives the app window, so a minted occurrence is reported as such even though
+ * the status/update leg that followed it was an ordinary quiet write.
+ */
+function recordComposite(deps, args) {
+    return appendCompositeSummary(deps, {
+        startedAt: args.startedAt,
+        op: args.op,
+        uuid: args.occurrence.occurrenceUuid,
+        txnId: args.txnId,
+        invocation: `${args.op} on repeating series ${args.occurrence.templateUuid}: ` +
+            `${args.occurrence.minted ? "create next copy, then " : ""}write ${args.occurrence.occurrenceUuid}`,
+        requested: args.requested,
+        vector: args.occurrence.minted ? "ui" : args.legResult.vector,
+        disruption: args.occurrence.minted ? 3 : args.legResult.tier,
+        options: args.options,
+        occurrence: args.occurrence,
+    });
+}
+// ------------------------------------------------------------ status writes
+/**
+ * `complete`/`cancel` aimed at a repeating to-do. Resolves the series' CURRENT
+ * occurrence: the open materialized one when it exists, otherwise the pending
+ * one, materialized first. The template itself is never written — CNC1 §6
+ * measured both status writes leaving it byte-unchanged, with the series
+ * continuing at its next date and exactly one occurrence per day.
+ */
+export async function runTemplateStatusWrite(deps, op, uuid, 
+/**
+ * The status write itself, applied to ONE ordinary occurrence. Injected
+ * rather than imported so the caller keeps ownership of its own vocabulary —
+ * `--completed-at` backdating, the children policy — and so this module does
+ * not have to import the resolution orchestrator that calls it.
+ */
+runStatusLeg, options = {}) {
+    const now = deps.now?.() ?? new Date();
+    return runComposite(deps, op, async () => {
+        const state = readSeriesState(deps, uuid);
+        if (state === null)
+            return blocked(op, "this to-do is no longer a repeating series", "retry");
+        const txnId = newTxnId(now);
+        let targetUuid;
+        let occurrenceDate;
+        let minted = false;
+        if (state.openInstance !== null) {
+            targetUuid = state.openInstance.uuid;
+            occurrenceDate = state.openInstance.startDate;
+        }
+        else {
+            if (state.cursor === null)
+                return noPendingRefusal(op, state);
+            const mint = await mintPendingOccurrence(deps, op, state.templateUuid, options, txnId);
+            if (!mint.ok)
+                return mint.result;
+            targetUuid = mint.uuid;
+            occurrenceDate = state.cursor;
+            minted = true;
+        }
+        const write = await runStatusLeg(targetUuid, legOptions(options, txnId));
+        if (write.kind !== "ok")
+            return { ...write, op };
+        const occurrence = {
+            templateUuid: state.templateUuid,
+            occurrenceUuid: targetUuid,
+            minted,
+            date: occurrenceDate,
+        };
+        const undoToken = recordComposite(deps, {
+            op,
+            startedAt: now,
+            txnId,
+            requested: { uuid: state.templateUuid },
+            occurrence,
+            legResult: write,
+            options,
+        });
+        const verb = op === "todo.complete" ? "checked off" : "canceled";
+        const nextDate = nextOccurrenceAfter(deps, state.templateUuid);
+        const disclosure = [
+            `${verb} ${occurrenceLabel(occurrenceDate)} of "${state.title}"` +
+                (minted ? " (created just now, because the series had no unfinished copy)" : ""),
+            nextDate === null
+                ? "the series has no further scheduled occurrence"
+                : state.afterCompletion
+                    ? `the next occurrence is ${nextDate} — this series counts from each completion, so ` +
+                        "resolving it now restarted the interval from today"
+                    : `the next occurrence is ${nextDate}`,
+        ];
+        if (minted)
+            disclosure.push(IRREVERSIBLE_NOTE);
+        return {
+            ...write,
+            op,
+            occurrence,
+            undoToken,
+            warnings: [...(write.warnings ?? []), ...disclosure],
+        };
+    });
+}
+// --------------------------------------------------------- exception writes
+/**
+ * `update --exception` aimed at a repeating to-do: change ONLY the next
+ * occurrence. Materializes the pending occurrence and applies the patch to it,
+ * which is what the app's own "make a one-time exception" does.
+ */
+export async function runTemplateExceptionWrite(deps, uuid, patch, options = {}) {
+    const op = "todo.update";
+    const now = deps.now?.() ?? new Date();
+    const todayIso = localToday(now, options.zone);
+    // Idempotency before the lock, like every refusal: a resubmitted key means the
+    // exception already landed, and re-running it would mint a SECOND occurrence
+    // (this composite always mints) and consume another of the series' slots.
+    const replay = replayIfApplied(deps, options);
+    if (replay !== null)
+        return replay;
+    return runComposite(deps, op, async () => {
+        const state = readSeriesState(deps, uuid);
+        if (state === null)
+            return blocked(op, "this to-do is no longer a repeating series", "retry");
+        if (state.cursor === null)
+            return noPendingRefusal(op, state);
+        // The collision refusal (CNC1 §2). A day the rule will still fire on ends up
+        // holding two copies of the series, and nothing in the app reconciles them.
+        const targetDay = whenTargetDay(typeof patch["when"] === "string" ? patch["when"] : undefined, todayIso);
+        if (targetDay !== null && !state.afterCompletion) {
+            // An after-completion series is exempt BY CONSTRUCTION, not by assumption:
+            // it has no calendar, so it owns exactly one future date — the cursor this
+            // mint is about to consume — and there is no second slot for the moved
+            // occurrence to collide with (CNCAC1 §7).
+            if (state.rule === null || state.rule.type !== "fixed") {
+                return blocked(op, "this series' schedule cannot be read, so there is no way to tell whether " +
+                    `${targetDay} is a day it already lands on`, "move the occurrence in the Things app, or change the whole series with " +
+                    "`things todo reschedule-repeat <ref>`");
+            }
+            if (liveSlotsAfterMint(state, targetDay).includes(targetDay)) {
+                return blocked(op, `"${state.title}" already lands on ${targetDay} — moving this occurrence there would ` +
+                    "leave two copies on that day, and the app does not merge them", "pick a day the series does not already land on, or change the whole series with " +
+                    "`things todo reschedule-repeat <ref>`");
+            }
+        }
+        const txnId = newTxnId(now);
+        const mint = await mintPendingOccurrence(deps, op, state.templateUuid, options, txnId);
+        if (!mint.ok)
+            return mint.result;
+        const write = await runMutation(deps, "todo.update", { uuid: mint.uuid, ...patch }, legOptions(options, txnId));
+        if (write.kind !== "ok") {
+            return {
+                ...write,
+                op,
+                ...("detail" in write
+                    ? {
+                        detail: `${write.detail} — the ${occurrenceLabel(state.cursor)} was created but not ` +
+                            `changed; it is now a plain to-do you can edit directly (${mint.uuid})`,
+                    }
+                    : {}),
+            };
+        }
+        const occurrence = {
+            templateUuid: state.templateUuid,
+            occurrenceUuid: mint.uuid,
+            // An exception ALWAYS mints: the semantics belong to the occurrence the
+            // rule has not spawned yet (see the module header).
+            minted: true,
+            date: state.cursor,
+        };
+        const undoToken = recordComposite(deps, {
+            op,
+            startedAt: now,
+            txnId,
+            requested: { uuid: state.templateUuid, ...patch },
+            occurrence,
+            legResult: write,
+            options,
+        });
+        const nextDate = nextOccurrenceAfter(deps, state.templateUuid);
+        return {
+            ...write,
+            op,
+            occurrence,
+            undoToken,
+            warnings: [
+                ...(write.warnings ?? []),
+                `changed only ${occurrenceLabel(state.cursor)} of "${state.title}" — the series itself is ` +
+                    "unchanged",
+                nextDate === null
+                    ? "the series has no further scheduled occurrence"
+                    : `the next occurrence is ${nextDate}`,
+                IRREVERSIBLE_NOTE,
+            ],
+        };
+    });
+}
+export { PROJECT_REFUSAL, PROJECT_REMEDIATION };
+//# sourceMappingURL=template-mutation.js.map

package/dist/write/template-mutation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-mutation.js","sourceRoot":"","sources":["../../src/write/template-mutation.ts"],"names":[],"mappings":"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"}