@openrig/cli 0.6.14 → 0.7.0

package/daemon/dist/domain/gateway/human-mode-account.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"human-mode-account.js","sourceRoot":"","sources":["../../../src/domain/gateway/human-mode-account.ts"],"names":[],"mappings":"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"}

package/daemon/dist/domain/gateway/human-operating-modes.d.ts

@@ -0,0 +1,171 @@
+import type Database from "better-sqlite3";
+import { HumanQuietStore } from "./human-quiet-windows.js";
+export type Availability = "available" | "focus" | "away" | "off";
+/** A quiet rule in the quiet-hours store's own shapes: a daily local rule, or until the application's end. */
+export type QuietRule = {
+    kind: "daily";
+    start: string;
+    end: string;
+    timezone: string;
+} | {
+    kind: "until-end";
+    timezone: string;
+};
+export interface SavedMode {
+    entityId: string;
+    name: string;
+    availability: {
+        value: Availability | null;
+        expectedBack: string | null;
+    };
+    /** Null: no decision room. Never inferred from the mode's name. */
+    decisionRoom: {
+        words: string;
+        exclusions: string[];
+    } | null;
+    delivery: {
+        quiet: QuietRule | null;
+        account: string | null;
+    };
+    setBy: string;
+    setAt: string;
+}
+export type EffectConsumer = "availability" | "quiet" | "decision-room";
+/** `handed-off`: a later mode applied while this effect's restore was still owed took over restoring its prior value. */
+export type EffectState = "active" | "pending" | "failed" | "ended" | "kept" | "handed-off";
+export interface ModeEffect {
+    consumer: EffectConsumer;
+    prior: unknown;
+    changeIdentity: unknown;
+    state: EffectState;
+    detail: string | null;
+    updatedAt: string;
+}
+export interface ModeApplication {
+    applicationId: string;
+    entityId: string;
+    modeName: string;
+    settings: SavedMode;
+    startedBy: string;
+    startedAt: string;
+    scheduledEnd: string | null;
+    endedAt: string | null;
+    endedBy: string | null;
+    endReason: EndReason | null;
+    effects: ModeEffect[];
+}
+export type EndReason = "back" | "scheduled" | "switched";
+export declare class ModeError extends Error {
+    readonly code: "invalid_mode" | "mode_not_found" | "end_required";
+    constructor(code: "invalid_mode" | "mode_not_found" | "end_required", message: string);
+}
+/** The two writers a mode changes outside its own tables; tests inject failing ones. */
+export interface AvailabilityAccess {
+    /** The authored value, and the id of the latest change recorded through the registry's writers (null: none yet). */
+    read(entityId: string): {
+        ok: true;
+        availability: string | undefined;
+        changeId?: string | null;
+        away?: boolean;
+    } | {
+        ok: false;
+        error: string;
+    };
+    /** changeId: the change record this write left (also on an error after the fragment and record were written). */
+    write(entityId: string, value: Availability | "unset"): {
+        ok: true;
+        changeId?: string;
+    } | {
+        ok: false;
+        error: string;
+        changeId?: string;
+    };
+    /** Set the legacy `away` flag. Ending a mode only clears one set while the mode's away was on; one the person had
+     *  before the mode is left as it is. */
+    setLegacyAway?(entityId: string, on: boolean): {
+        ok: true;
+    } | {
+        ok: false;
+        error: string;
+    };
+}
+export declare function registryAvailability(home: string): AvailabilityAccess;
+/** Mode names are compared in one spelling: lower case, words joined by hyphens ("Away from desk" is away-from-desk). */
+export declare function modeName(raw: string): string;
+export declare const AT_DESK = "at-desk";
+export declare class HumanModeService {
+    private readonly deps;
+    private readonly quiet;
+    /** `availability` is needed only to apply or end a mode; reading saved modes and applications works without it. */
+    /** `armScheduledEnd` arms the timer that ends an application at its scheduled end; it runs with the application's insert,
+     *  so one never commits without the other. */
+    constructor(deps: {
+        db: Database.Database;
+        availability?: AvailabilityAccess;
+        quiet?: HumanQuietStore;
+        now?: () => Date;
+        armScheduledEnd?: (application: {
+            applicationId: string;
+            entityId: string;
+            scheduledEnd: string;
+        }) => void;
+    });
+    private get availability();
+    private now;
+    save(entityId: string, input: {
+        name: string;
+        availability?: {
+            value?: string | null;
+            expectedBack?: string | null;
+        };
+        decisionRoom?: {
+            words?: string | null;
+            exclusions?: string[];
+        } | null;
+        delivery?: {
+            quiet?: QuietRule | null;
+            account?: string | null;
+        };
+    }, actor: string): SavedMode;
+    saved(entityId: string, name: string): SavedMode | null;
+    list(entityId: string): SavedMode[];
+    /** The person's active application, or null: at desk. */
+    current(entityId: string): ModeApplication | null;
+    get(applicationId: string): ModeApplication | null;
+    /** Apply a saved mode. At desk ends the current application and applies nothing. Another active mode is ended first
+     *  (a switch), so a person has at most one. */
+    apply(entityId: string, name: string, input: {
+        scheduledEnd?: Date | null;
+    }, actor: string): {
+        application: ModeApplication | null;
+        ended: ModeApplication | null;
+    };
+    /** End the person's active application: each effect ends only if the latest change is still its own. Returns the
+     *  ended application, or null when none was active. Every time, restorations still pending or failed from earlier
+     *  applications are tried again (see unresolved), so a later mode never hides an older one's. */
+    end(entityId: string, reason: EndReason, actor: string): ModeApplication | null;
+    /** End this application, and only while it's still the one on: a timer armed for it never ends a later mode the person
+     *  switched to. Null when it has already ended. */
+    endIfStill(applicationId: string, reason: EndReason, actor: string): ModeApplication | null;
+    /** Restorations from ended applications that are still pending or failed: owed in the coming-back report, and tried
+     *  again by every end. Oldest application first. */
+    unresolved(entityId: string): Array<{
+        applicationId: string;
+        modeName: string;
+        endedAt: string;
+        effect: ModeEffect;
+    }>;
+    private unresolvedApplicationIds;
+    private endEffects;
+    /** The latest earlier application's still-owed restore of this consumer, if its change is still the live one. */
+    private owedStillOwn;
+    /** Close an earlier effect whose restore a later mode took over: not kept (nobody chose otherwise), not ended (nothing
+     *  was restored yet), but handed to the mode that now restores its prior value. */
+    private handOff;
+    private endAvailability;
+    private endQuiet;
+    private effect;
+    private effects;
+    private application;
+}
+//# sourceMappingURL=human-operating-modes.d.ts.map

package/daemon/dist/domain/gateway/human-operating-modes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"human-operating-modes.d.ts","sourceRoot":"","sources":["../../../src/domain/gateway/human-operating-modes.ts"],"names":[],"mappings":"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"}

package/daemon/dist/domain/gateway/human-operating-modes.js

@@ -0,0 +1,422 @@
+import { randomUUID } from "node:crypto";
+import { HumanQuietStore } from "./human-quiet-windows.js";
+import { readHumanAvailability, setHumanField } from "./human-registry.js";
+const AVAILABILITY = new Set(["available", "focus", "away", "off"]);
+export class ModeError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "ModeError";
+    }
+}
+export function registryAvailability(home) {
+    return {
+        read: (entityId) => readHumanAvailability(entityId, home),
+        write: (entityId, value) => {
+            const res = setHumanField(entityId, "availability", value, home);
+            return res.ok ? { ok: true, changeId: res.changeId } : { ok: false, error: res.error, changeId: res.changeId };
+        },
+        setLegacyAway: (entityId, on) => {
+            const res = setHumanField(entityId, "away", on ? "true" : "false", home);
+            return res.ok ? { ok: true } : { ok: false, error: res.error };
+        },
+    };
+}
+/** Mode names are compared in one spelling: lower case, words joined by hyphens ("Away from desk" is away-from-desk). */
+export function modeName(raw) {
+    return raw.trim().toLowerCase().replace(/[\s_]+/g, "-");
+}
+export const AT_DESK = "at-desk";
+export class HumanModeService {
+    deps;
+    quiet;
+    /** `availability` is needed only to apply or end a mode; reading saved modes and applications works without it. */
+    /** `armScheduledEnd` arms the timer that ends an application at its scheduled end; it runs with the application's insert,
+     *  so one never commits without the other. */
+    constructor(deps) {
+        this.deps = deps;
+        this.quiet = deps.quiet ?? new HumanQuietStore(deps.db);
+    }
+    get availability() {
+        if (!this.deps.availability)
+            throw new Error("applying or ending a mode needs the availability writer");
+        return this.deps.availability;
+    }
+    now() { return this.deps.now?.() ?? new Date(); }
+    save(entityId, input, actor) {
+        const name = modeName(input.name);
+        if (!name)
+            throw new ModeError("invalid_mode", "a mode needs a name");
+        if (name === AT_DESK)
+            throw new ModeError("invalid_mode", "at desk is no mode applied, so it isn't saved: apply it to end the current mode");
+        const value = input.availability?.value ?? null;
+        if (value !== null && !AVAILABILITY.has(value))
+            throw new ModeError("invalid_mode", `availability must be one of available|focus|away|off (got "${value}")`);
+        const words = input.decisionRoom?.words?.trim() || null;
+        const exclusions = input.decisionRoom?.exclusions ?? [];
+        if (!words && exclusions.length > 0)
+            throw new ModeError("invalid_mode", "exclusions read back from a decision room need the person's words for it");
+        const quiet = input.delivery?.quiet ?? null;
+        if (quiet)
+            validateQuietRule(quiet);
+        const at = this.now().toISOString();
+        this.deps.db.prepare(`INSERT INTO human_saved_modes (entity_id, name, availability, expected_back, decision_room_words,
+        decision_room_exclusions, quiet_rule, account_destination, set_by, set_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT (entity_id, name) DO UPDATE SET availability = excluded.availability, expected_back = excluded.expected_back,
+        decision_room_words = excluded.decision_room_words, decision_room_exclusions = excluded.decision_room_exclusions,
+        quiet_rule = excluded.quiet_rule, account_destination = excluded.account_destination, set_by = excluded.set_by,
+        set_at = excluded.set_at`)
+            .run(entityId, name, value, input.availability?.expectedBack ?? null, words, JSON.stringify(words ? exclusions : []), quiet ? JSON.stringify(quiet) : null, input.delivery?.account ?? null, actor, at);
+        return this.saved(entityId, name);
+    }
+    saved(entityId, name) {
+        const row = this.deps.db.prepare(`SELECT * FROM human_saved_modes WHERE entity_id = ? AND name = ?`).get(entityId, modeName(name));
+        return row ? toSaved(row) : null;
+    }
+    list(entityId) {
+        return this.deps.db.prepare(`SELECT * FROM human_saved_modes WHERE entity_id = ? ORDER BY name`).all(entityId).map(toSaved);
+    }
+    /** The person's active application, or null: at desk. */
+    current(entityId) {
+        const row = this.deps.db.prepare(`SELECT * FROM human_mode_applications WHERE entity_id = ? AND ended_at IS NULL`).get(entityId);
+        return row ? this.application(row) : null;
+    }
+    get(applicationId) {
+        const row = this.deps.db.prepare(`SELECT * FROM human_mode_applications WHERE application_id = ?`).get(applicationId);
+        return row ? this.application(row) : null;
+    }
+    /** Apply a saved mode. At desk ends the current application and applies nothing. Another active mode is ended first
+     *  (a switch), so a person has at most one. */
+    apply(entityId, name, input, actor) {
+        const wanted = modeName(name);
+        const at = this.now();
+        if (wanted === AT_DESK)
+            return { application: null, ended: this.end(entityId, "back", actor) };
+        const mode = this.saved(entityId, wanted);
+        if (!mode)
+            throw new ModeError("mode_not_found", `${entityId} has no saved mode "${wanted}": save it first`);
+        const scheduledEnd = input.scheduledEnd ?? null;
+        if (scheduledEnd && scheduledEnd.getTime() <= at.getTime())
+            throw new ModeError("end_required", `${scheduledEnd.toISOString()} has already passed`);
+        if (mode.delivery.quiet?.kind === "until-end" && !scheduledEnd) {
+            throw new ModeError("end_required", `"${wanted}" keeps quiet hours until the mode ends, so applying it needs an end time`);
+        }
+        const ended = this.end(entityId, "switched", actor);
+        const applicationId = randomUUID();
+        this.deps.db.transaction(() => {
+            this.deps.db.prepare(`INSERT INTO human_mode_applications (application_id, entity_id, mode_name, settings, started_by, started_at, scheduled_end)
+        VALUES (?, ?, ?, ?, ?, ?, ?)`).run(applicationId, entityId, wanted, JSON.stringify(mode), actor, at.toISOString(), scheduledEnd?.toISOString() ?? null);
+            if (scheduledEnd)
+                this.deps.armScheduledEnd?.({ applicationId, entityId, scheduledEnd: scheduledEnd.toISOString() });
+        })();
+        // Each effect is its own step: one that throws is recorded as that effect's failure and never stops the others, so the
+        // record always shows every effect's real state.
+        const step = (consumer, run) => {
+            try {
+                run();
+            }
+            catch (error) {
+                this.effect(applicationId, consumer, null, null, "failed", `couldn't apply it: ${error.message}`);
+            }
+        };
+        if (mode.availability.value) {
+            const value = mode.availability.value;
+            step("availability", () => {
+                const prior = this.availability.read(entityId);
+                if (!prior.ok) {
+                    this.effect(applicationId, "availability", null, null, "failed", `couldn't read the current availability: ${prior.error}`);
+                    return;
+                }
+                // An earlier mode whose restore is still owed, and whose change is still the live one: its prior is the real one.
+                const owed = this.owedStillOwn(entityId, "availability", (identity) => {
+                    // Absence compares as absence: the registry reads an unset value as undefined, and a partial unset restore is
+                    // recorded with null.
+                    const id = identity;
+                    return (prior.availability ?? null) === (id.availability ?? null) && (id.changeId == null || prior.changeId === id.changeId);
+                });
+                const wrote = this.availability.write(entityId, value);
+                // The change identity is the change record the mode's own write left, as the writer returns it (so a manual write
+                // landing right after it is never taken for the mode's), with the value. A write can also fail after the fragment
+                // and record are saved (re-projecting it fails); its id comes back with the error, the value is live on the next
+                // load, and the change is still the mode's own, so ending puts the prior value back. A writer that returns no id
+                // (an injected one, or a record that couldn't be written) falls back to reading the record back after the write.
+                const after = wrote.changeId ? null : this.availability.read(entityId);
+                const landed = wrote.changeId ? { availability: value, changeId: wrote.changeId }
+                    : after?.ok && after.availability === value ? { availability: value, changeId: after.changeId ?? null } : null;
+                // The prior state is the authored availability and the legacy away flag, so ending can put back exactly what the
+                // person had (an inherited prior carries both).
+                const priorValue = owed?.effect.prior
+                    ?? { availability: prior.availability ?? null, away: prior.away ?? false };
+                if (wrote.ok && landed)
+                    this.effect(applicationId, "availability", priorValue, landed, "active", null);
+                else
+                    this.effect(applicationId, "availability", priorValue, landed, "failed", wrote.ok ? "written, but it didn't read back as written" : wrote.error);
+                if (owed && landed)
+                    this.handOff(owed, applicationId, mode.name, `availability ${priorValue.availability ?? "not set"}`);
+            });
+        }
+        if (mode.delivery.quiet) {
+            const rule = mode.delivery.quiet;
+            step("quiet", () => {
+                let prior;
+                try {
+                    prior = this.quiet.show(entityId);
+                }
+                catch (error) {
+                    // Nothing is written when what's there now can't be read: there would be nothing honest to restore.
+                    this.effect(applicationId, "quiet", null, null, "failed", `couldn't read the current quiet hours: ${error.message}`);
+                    return;
+                }
+                const owed = this.owedStillOwn(entityId, "quiet", (identity) => {
+                    const id = identity;
+                    return !!prior && prior.revision === id.revision && prior.source === id.source;
+                });
+                if (owed)
+                    prior = owed.effect.prior;
+                const source = `mode-application:${applicationId}`;
+                try {
+                    const window = rule.kind === "daily"
+                        ? this.quiet.setDaily(entityId, { start: rule.start, end: rule.end, timezone: rule.timezone, setBy: actor, now: at, source })
+                        : this.quiet.setUntil(entityId, { until: scheduledEnd, timezone: rule.timezone, setBy: actor, now: at, source });
+                    this.effect(applicationId, "quiet", prior, { windowId: window.windowId, revision: window.revision, source }, "active", null);
+                    if (owed)
+                        this.handOff(owed, applicationId, mode.name, describeQuiet(prior));
+                }
+                catch (error) {
+                    this.effect(applicationId, "quiet", prior, null, "failed", error.message);
+                }
+            });
+        }
+        if (mode.decisionRoom)
+            step("decision-room", () => this.effect(applicationId, "decision-room", null, { applicationId }, "active", null));
+        // The switch's ended snapshot is read again, so it shows any effect this apply has since handed off.
+        return { application: this.get(applicationId), ended: ended ? this.get(ended.applicationId) : null };
+    }
+    /** End the person's active application: each effect ends only if the latest change is still its own. Returns the
+     *  ended application, or null when none was active. Every time, restorations still pending or failed from earlier
+     *  applications are tried again (see unresolved), so a later mode never hides an older one's. */
+    end(entityId, reason, actor) {
+        const at = this.now();
+        const row = this.deps.db.prepare(`SELECT * FROM human_mode_applications WHERE entity_id = ? AND ended_at IS NULL`).get(entityId);
+        if (row) {
+            this.deps.db.prepare(`UPDATE human_mode_applications SET ended_at = ?, ended_by = ?, end_reason = ? WHERE application_id = ?`)
+                .run(at.toISOString(), actor, reason, row.application_id);
+            this.endEffects(entityId, row.application_id, actor, at);
+        }
+        for (const earlier of this.unresolvedApplicationIds(entityId)) {
+            if (earlier !== row?.application_id)
+                this.endEffects(entityId, earlier, actor, at);
+        }
+        return row ? this.get(row.application_id) : null;
+    }
+    /** End this application, and only while it's still the one on: a timer armed for it never ends a later mode the person
+     *  switched to. Null when it has already ended. */
+    endIfStill(applicationId, reason, actor) {
+        const row = this.deps.db.prepare(`SELECT entity_id FROM human_mode_applications WHERE application_id = ? AND ended_at IS NULL`)
+            .get(applicationId);
+        return row ? this.end(row.entity_id, reason, actor) : null;
+    }
+    /** Restorations from ended applications that are still pending or failed: owed in the coming-back report, and tried
+     *  again by every end. Oldest application first. */
+    unresolved(entityId) {
+        const out = [];
+        for (const id of this.unresolvedApplicationIds(entityId)) {
+            const app = this.get(id);
+            for (const effect of app.effects) {
+                if (effect.state === "pending" || (effect.state === "failed" && effect.changeIdentity !== null)) {
+                    out.push({ applicationId: id, modeName: app.modeName, endedAt: app.endedAt, effect });
+                }
+            }
+        }
+        return out;
+    }
+    unresolvedApplicationIds(entityId) {
+        return this.deps.db.prepare(`SELECT DISTINCT a.application_id AS id, a.started_at FROM human_mode_applications a
+        JOIN human_mode_effects e ON e.application_id = a.application_id
+        WHERE a.entity_id = ? AND a.ended_at IS NOT NULL
+          AND (e.state = 'pending' OR (e.state = 'failed' AND e.change_identity IS NOT NULL))
+        ORDER BY a.started_at`).all(entityId).map((r) => r.id);
+    }
+    endEffects(entityId, applicationId, actor, at) {
+        for (const effect of this.effects(applicationId)) {
+            if (effect.state === "ended" || effect.state === "kept" || effect.state === "handed-off")
+                continue;
+            if (effect.state === "failed" && effect.changeIdentity === null) {
+                this.effect(applicationId, effect.consumer, effect.prior, null, "ended", "it never took effect when the mode started, so there was nothing to undo");
+                continue;
+            }
+            // As when applying: a throw while ending one effect is that effect's failure, never the others'.
+            try {
+                if (effect.consumer === "decision-room")
+                    this.effect(applicationId, "decision-room", null, effect.changeIdentity, "ended", null);
+                else if (effect.consumer === "availability")
+                    this.endAvailability(entityId, applicationId, effect);
+                else
+                    this.endQuiet(entityId, applicationId, effect, actor, at);
+            }
+            catch (error) {
+                this.effect(applicationId, effect.consumer, effect.prior, effect.changeIdentity, "failed", `couldn't end it: ${error.message}`);
+            }
+        }
+    }
+    /** The latest earlier application's still-owed restore of this consumer, if its change is still the live one. */
+    owedStillOwn(entityId, consumer, stillOwn) {
+        const owed = this.unresolved(entityId).filter((u) => u.effect.consumer === consumer).at(-1);
+        return owed && owed.effect.changeIdentity !== null && stillOwn(owed.effect.changeIdentity) ? owed : null;
+    }
+    /** Close an earlier effect whose restore a later mode took over: not kept (nobody chose otherwise), not ended (nothing
+     *  was restored yet), but handed to the mode that now restores its prior value. */
+    handOff(owed, toApplicationId, toMode, prior) {
+        this.effect(owed.applicationId, owed.effect.consumer, owed.effect.prior, owed.effect.changeIdentity, "handed-off", `handed to ${toMode} (${toApplicationId}), which restores ${prior} when it ends`);
+    }
+    endAvailability(entityId, applicationId, effect) {
+        // The identity is what the mode itself last wrote: its own value when the mode started, or, after a restore that
+        // saved but failed to re-project, the restored value with that restore's change id (so a retry finishes it).
+        const identity = effect.changeIdentity;
+        const wrote = identity.availability ?? null;
+        // A snapshot without `away` (only in data from before the flag was recorded, never merged) reads as false.
+        const { availability: prior, away: priorAway = false } = effect.prior;
+        const now = this.availability.read(entityId);
+        if (!now.ok) {
+            this.effect(applicationId, "availability", effect.prior, effect.changeIdentity, "pending", `couldn't read the current availability to check it's still this mode's: ${now.error}`);
+            return;
+        }
+        // Still the mode's own only if the latest recorded change is the mode's (so away, then focus, then away by hand is
+        // not) and the value is the one it wrote (so a hand edit of the file is not). A record from before change ids
+        // existed falls back to the value alone.
+        const sameChange = identity.changeId == null || now.changeId === identity.changeId;
+        const nowValue = now.availability ?? null; // an unset value reads undefined, and is recorded as null
+        if (nowValue !== wrote || !sameChange) {
+            this.effect(applicationId, "availability", effect.prior, effect.changeIdentity, "kept", `changed since the mode started (now ${now.availability ?? "not set"}${nowValue === wrote ? ", set again since" : ""}); that choice stands`);
+            return;
+        }
+        // A legacy `away: true` added while the mode's away was on only agreed with it, and it would contradict a value being
+        // put back (the registry refuses the pair), so it goes first, while availability is still authored (then clearing it
+        // changes nothing about availability and leaves the change record alone). A flag the person had before the mode is
+        // theirs and is left as it is.
+        const setAway = this.availability.setLegacyAway;
+        if (now.away && !priorAway && prior !== "away" && setAway) {
+            const cleared = setAway(entityId, false);
+            if (!cleared.ok) {
+                this.effect(applicationId, "availability", effect.prior, effect.changeIdentity, "failed", `couldn't clear away before restoring ${prior ?? "not set"}: ${cleared.error}`);
+                return;
+            }
+        }
+        const restored = this.availability.write(entityId, (prior ?? "unset"));
+        // A restore that failed after the fragment and record were written (re-projecting failed) carries its change id: the
+        // live state is the mode's own restore, so the failure records that restore's identity, the retry recognises it and
+        // finishes, and a later manual change still reads as the person's. The prior stays.
+        if (!restored.ok) {
+            const restoredIdentity = restored.changeId ? { availability: prior, changeId: restored.changeId } : null;
+            this.effect(applicationId, "availability", effect.prior, restoredIdentity ?? effect.changeIdentity, "failed", `couldn't restore ${prior ?? "not set"}: ${restored.error}`);
+            return;
+        }
+        let detail = `restored to ${prior ?? "not set"}`;
+        if (prior === null && priorAway) {
+            // Their own legacy away from before the mode is left as it is: OpenRig never clears a flag that was on before, so if
+            // it's off now the person turned it off during the mode, and that's their "I'm back".
+            detail += now.away ? "; away stays on, as it was before the mode" : "; away was turned off during the mode; that choice stands";
+        }
+        else if (now.away && !priorAway && prior !== "away") {
+            detail += "; the away flag set during it is cleared";
+        }
+        this.effect(applicationId, "availability", effect.prior, effect.changeIdentity, "ended", detail);
+    }
+    endQuiet(entityId, applicationId, effect, actor, at) {
+        const wrote = effect.changeIdentity;
+        const prior = effect.prior;
+        try {
+            const now = this.quiet.show(entityId);
+            if (!now || now.revision !== wrote.revision || now.source !== wrote.source) {
+                this.effect(applicationId, "quiet", effect.prior, effect.changeIdentity, "kept", now ? `quiet hours were changed since the mode started (now revision ${now.revision}, set by ${now.setBy}); they stay as set`
+                    : "quiet hours were cleared since the mode started; they stay cleared");
+                return;
+            }
+            // Still the mode's own rule: put back what was there before it, as it was, in one transaction with any ended mark
+            // carried across, so no reader sees quiet restarted in between. The mark is the person's own "I'm back" for
+            // tonight during the mode (a manual end changes tonight, not the rule), or the prior window's mark for an
+            // occurrence that is still the current one.
+            const personEnded = now.ended ?? null;
+            let detail = "";
+            this.deps.db.transaction(() => {
+                if (prior && prior.kind === "daily") {
+                    const w = this.quiet.setDaily(entityId, { start: prior.start, end: prior.end, timezone: prior.timezone, setBy: actor, now: at, source: prior.source });
+                    detail = `restored the daily quiet hours ${prior.start}-${prior.end} ${prior.timezone} (revision ${w.revision})`;
+                }
+                else if (prior && prior.kind === "until" && Date.parse(prior.until) > at.getTime()) {
+                    const w = this.quiet.setUntil(entityId, { until: new Date(prior.until), timezone: prior.timezone, setBy: actor, now: at, source: prior.source });
+                    detail = `restored quiet hours until ${prior.until} (revision ${w.revision})`;
+                }
+                else {
+                    const c = this.quiet.clear(entityId, { clearedBy: actor, now: at });
+                    detail = prior ? `the quiet hours before it had already run out, so none were restored (revision ${c.revision})` : `cleared the mode's quiet hours (revision ${c.revision})`;
+                    return;
+                }
+                const state = this.quiet.quietStateFor(entityId, at);
+                if (!state.active)
+                    return;
+                // A mark carries only if the person ended quiet within the occurrence that is on now: from its start up to now.
+                // Judged by time, not by the occurrence's label (the person's mark may be on a different rule's occurrence), so
+                // neither an earlier night's mark nor an old one from before this occurrence began carries. A restored
+                // until-window's one occurrence began when the prior rule was set (the restore itself writes a new set time).
+                const occurrenceStart = Date.parse(prior?.kind === "until" ? prior.setAt : state.occurrenceStart);
+                const tonight = (ended) => ended && Date.parse(ended.at) >= occurrenceStart && Date.parse(ended.at) < at.getTime() ? ended : null;
+                const mark = tonight(personEnded) ?? tonight(prior?.ended);
+                if (!mark)
+                    return;
+                this.quiet.restoreEnded(entityId, state.revision, { occurrence: state.occurrence, by: mark.by, at: mark.at });
+                detail += "; tonight stays off, as you set it";
+            })();
+            this.effect(applicationId, "quiet", effect.prior, effect.changeIdentity, "ended", detail);
+        }
+        catch (error) {
+            this.effect(applicationId, "quiet", effect.prior, effect.changeIdentity, "failed", `couldn't restore quiet hours: ${error.message}`);
+        }
+    }
+    effect(applicationId, consumer, prior, changeIdentity, state, detail) {
+        this.deps.db.prepare(`INSERT INTO human_mode_effects (application_id, consumer, prior, change_identity, state, detail, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?) ON CONFLICT (application_id, consumer) DO UPDATE SET prior = excluded.prior,
+        change_identity = excluded.change_identity, state = excluded.state, detail = excluded.detail, updated_at = excluded.updated_at`)
+            .run(applicationId, consumer, prior === undefined ? null : JSON.stringify(prior), changeIdentity === null ? null : JSON.stringify(changeIdentity), state, detail, this.now().toISOString());
+    }
+    effects(applicationId) {
+        return this.deps.db.prepare(`SELECT * FROM human_mode_effects WHERE application_id = ? ORDER BY consumer`).all(applicationId)
+            .map((r) => ({ consumer: r.consumer, prior: r.prior === null ? null : JSON.parse(r.prior), changeIdentity: r.change_identity === null ? null : JSON.parse(r.change_identity),
+            state: r.state, detail: r.detail, updatedAt: r.updated_at }));
+    }
+    application(row) {
+        return { applicationId: row.application_id, entityId: row.entity_id, modeName: row.mode_name, settings: JSON.parse(row.settings),
+            startedBy: row.started_by, startedAt: row.started_at, scheduledEnd: row.scheduled_end, endedAt: row.ended_at, endedBy: row.ended_by,
+            endReason: row.end_reason, effects: this.effects(row.application_id) };
+    }
+}
+function validateQuietRule(rule) {
+    const hhmm = /^([01]\d|2[0-3]):([0-5]\d)$/;
+    if (rule.kind === "daily") {
+        if (!hhmm.test(rule.start) || !hhmm.test(rule.end))
+            throw new ModeError("invalid_mode", "a daily quiet rule needs start and end as 24-hour HH:MM");
+        if (rule.start === rule.end)
+            throw new ModeError("invalid_mode", "a daily quiet rule's start and end are the same time");
+    }
+    else if (rule.kind !== "until-end") {
+        throw new ModeError("invalid_mode", `a quiet rule is daily or until-end (got "${rule.kind}")`);
+    }
+    if (!rule.timezone)
+        throw new ModeError("invalid_mode", "a quiet rule needs a timezone");
+}
+function toSaved(row) {
+    return {
+        entityId: row.entity_id, name: row.name,
+        availability: { value: row.availability, expectedBack: row.expected_back },
+        decisionRoom: row.decision_room_words ? { words: row.decision_room_words, exclusions: JSON.parse(row.decision_room_exclusions) } : null,
+        delivery: { quiet: row.quiet_rule ? JSON.parse(row.quiet_rule) : null, account: row.account_destination },
+        setBy: row.set_by, setAt: row.set_at,
+    };
+}
+function describeQuiet(window) {
+    if (!window)
+        return "no quiet hours";
+    return window.kind === "daily" ? `the daily quiet hours ${window.start}-${window.end} ${window.timezone}` : `quiet hours until ${window.until}`;
+}
+//# sourceMappingURL=human-operating-modes.js.map