waterplane 0.0.1 → 0.1.11

package/node_modules/@waterplane/shared/dist/schedule/schedrule.d.ts

@@ -0,0 +1,219 @@
+/** How late a missed occurrence may still run, by default (minutes). Two hours:
+ *  long enough to survive a lunch-time sleep, short enough that a laptop opened
+ *  on Saturday doesn't fire Thursday's sweep. */
+export declare const DEFAULT_GRACE_MIN = 120;
+/** Weekday labels, index = `Date.getDay()`. */
+export declare const DAY_LABELS: string[];
+/**
+ * When a schedule fires.
+ *
+ * Two independent questions live in this type. `kind` is the ANCHOR — an
+ * absolute instant, a weekly wall clock, or a usage reset — and decides which
+ * of the fields below are read at all. `oneShot` is the RECURRENCE — does this
+ * rule keep standing after it fires, or was it "just this once" — and it is
+ * orthogonal to the anchor: "tonight 23:00" and "every Thursday 18:00" are the
+ * same clock anchor with two different answers to how often, and a weekly wall
+ * clock or a usage reset is entitled to the same pair. `kind: "once"` already
+ * IS the clock anchor's one-shot (an absolute instant has no "every" to ask
+ * for), which is why `oneShot` is never set there — one way to say each thing.
+ * Use `ruleRecurs`/`ruleAnchor` to read the two questions apart; nothing else
+ * in this file keys on `kind` alone to mean "does this repeat".
+ *
+ * `once` carries an absolute instant (the phone resolves "tonight 23:00" with
+ * the device's own clock — there is no recurrence to drift). `weekly` carries a
+ * wall clock plus its zone, re-resolved per occurrence; `days` empty means every
+ * day, which is how "daily" is expressed without a third variant.
+ */
+export interface ScheduleRule {
+    kind: "once" | "weekly" | "window";
+    /** `once`: the anchor instant, epoch ms. */
+    at?: number;
+    /** `weekly`: anchor days, 0 = Sunday .. 6 = Saturday. Empty ⇒ every day. */
+    days?: number[];
+    /** `weekly`: anchor wall clock in `tz`. */
+    hour?: number;
+    minute?: number;
+    /** IANA zone the anchor is expressed in, e.g. "Europe/Berlin". */
+    tz?: string;
+    /** Shift from the anchor, minutes. NEGATIVE = before it ("2h before the reset"). */
+    offsetMin?: number;
+    /**
+     * `weekly` and `window` only: fire the next occurrence and stop, rather than
+     * every one — "next Thursday 18:00, then done" or "next time my session
+     * window resets, then done". Absent means it recurs, which is what every rule
+     * written before this field existed meant and still means: a reader that does
+     * not know this field drops it and gets exactly the old behaviour. Never set
+     * on `once` — that kind already names a single instant with nothing to repeat.
+     */
+    oneShot?: boolean;
+    /**
+     * The hours of the day this rule may actually RUN — quiet hours, stated as
+     * the window they leave open, in minutes of day in `tz`. Absent ⇒ any hour,
+     * which is what every rule written before this field existed meant and still
+     * means: a reader that does not know it drops it and gets the old behaviour.
+     *
+     * It is NOT a second anchor and it never moves the occurrence. `nextFireAt`
+     * places the fire exactly where it always did; this decides whether the
+     * instant it landed on is one the machine may speak at. The two are kept
+     * apart for the same reason the anchor and the lead time are: "every day at
+     * 03:00" and "the moment the weekly window comes back" are facts about when
+     * the work becomes worth doing, and "not while I am asleep" is a policy over
+     * all of them. Folded into the anchor, the policy would have to be re-derived
+     * into every rule that carries it, and the row could no longer say what it is
+     * tracking — which is the complaint `describeRule` has made since before
+     * there was a reset to anchor to.
+     *
+     * It WRAPS midnight (`{from: 1320, to: 420}` is 22:00–07:00), because the
+     * window people actually name is the night one; a pair that could not cross
+     * midnight would have to be written as two rules that then drift apart.
+     * `from === to` is DROPPED by `cleanRule` rather than read as "always" or as
+     * "never" — a window with no width is a rule that can never fire, and a
+     * schedule that quietly stops mattering is the one failure this file is
+     * built against.
+     *
+     * The GRACE is measured from the moment the window OPENS, not from the
+     * anchor (`intentVerdict`'s `at` arm, and `hoursOpenFrom` below). A rule
+     * anchored at 03:00 with a 07:00–22:00 window would otherwise spend its whole
+     * grace asleep and report itself missed at the first instant it was allowed
+     * to run — a schedule that can only ever fail, which is worse than one that
+     * never fires, because it fails loudly at the user every day.
+     */
+    hours?: {
+        from: number;
+        to: number;
+    };
+    /** Which reset this rule tracks. */
+    window?: "session" | "weekly";
+    /**
+     * `window` only: the budget PERIOD this rule tracks, when it is not one of the
+     * two scraped windows - a calendar `month`/`week`/`day` or a span (`PeriodId`).
+     * Absent means `window` says it (and `session`/`weekly` stay valid ids). A
+     * rolling period has no reset edge and `windowRuleRefusal` (period.ts) refuses
+     * it with a sentence. When set, `window` is `session` (the default) and means
+     * nothing; read the anchor through `anchorPeriodId`.
+     */
+    periodId?: string;
+    /**
+     * Which side of it.
+     *
+     * `before` fires `offsetMin` ahead of the reset — the "spend what is left"
+     * case, and the only one a condition makes sense for.
+     * `after` fires at the reset itself (plus `offsetMin` if given) — the "start
+     * the moment the allowance is back" case, which is unconditional by nature:
+     * a window that has just reset is by definition empty.
+     */
+    edge?: "before" | "after";
+    /**
+     * `before` only: run only if at least this much of the allowance is still
+     * UNUSED, 0..100. Absent ⇒ no condition.
+     *
+     * Expressed as what is LEFT rather than what is used, because that is the
+     * question being asked — "is there enough headroom to be worth spending?" —
+     * and because the percentage on the screen it is compared against is a USED
+     * figure, so naming this one the same way would make every reading of the
+     * pair an inversion somebody has to do in their head.
+     */
+    minPctLeft?: number;
+    /**
+     * Test `minPctLeft` against the OTHER usage window.
+     *
+     * The instruction this exists for cannot be written otherwise: *"right after
+     * the session window resets, but only if 30% of the week is left"*. The
+     * ANCHOR has to be the session reset — that is the instant the work becomes
+     * possible — and the CONDITION has to be about the week, because the week is
+     * the allowance a thirteen-repo sweep actually eats. One `window` field
+     * answered both questions, so naming one of them meant giving up the other,
+     * and the shape people kept asking for was exactly the one it could not hold.
+     *
+     * Absent ⇒ the condition tests the window the rule is anchored to, which is
+     * what every rule written before this field meant. Naming the SAME window is
+     * not a guard at all and `cleanRule` drops it — one way to say each thing.
+     *
+     * It is also the one thing that lifts the `after`-edge rule above. A window
+     * that has just reset is empty by definition, so a condition on THAT window
+     * could only ever mean "never run"; a condition on the other one is a real
+     * question with a real answer, and refusing it was refusing the only shape
+     * anybody wanted an `after` edge with a condition for.
+     */
+    guardWindow?: "session" | "weekly";
+}
+/** The anchor a rule is measured against — the question `kind` answers once
+ *  `oneShot` has been read apart from it. */
+export type RuleAnchor = "clock" | "window";
+/** Which anchor. `once` and `weekly` are both clock-anchored; only `window`
+ *  tracks a usage reset instead of a time of day. */
+export declare function ruleAnchor(rule: ScheduleRule): RuleAnchor;
+/**
+ * **Does this rule keep standing after it fires?** The one answer for
+ * "is this a schedule, or a thing that happens once" — the host's arm/settle
+ * logic, the schedule sheet's pause-vs-on/off split, and the verdict ladder's
+ * one-off branch all ask here rather than hand-rolling `kind !== "once"`,
+ * which stopped being a complete answer the day `oneShot` could apply to a
+ * `weekly` or `window` rule too.
+ */
+export declare function ruleRecurs(rule: ScheduleRule): boolean;
+/**
+ * (anchor, recurrence) → a rule, carrying over whatever still means the same
+ * thing across the switch. The one encoder: a UI control renders the two
+ * questions as two toggles and never hand-rolls which `kind`/`oneShot` pair a
+ * choice maps to.
+ *
+ * `offsetMin` crosses anchors because it is a LEAD TIME in both: negative on a
+ * `weekly` rule and negative on a `before`-edge `window` rule mean the same
+ * thing ("fire this long ahead of the anchor"). A positive `window` `before`
+ * offset does not exist (`cleanRule` clamps it), so nothing is lost crossing
+ * the other way.
+ *
+ * `hours` crosses for a stronger reason: it is not about the anchor at all. "I
+ * am asleep between 22:00 and 07:00" stays true whichever instant the rule is
+ * hung off, and dropping it at the switch would silently re-open a door the
+ * user shut. `guardWindow` does NOT cross — it names one of two usage windows
+ * and means nothing on a wall clock — so it rides on `src` like `minPctLeft`,
+ * the field it exists to redirect.
+ */
+export declare function composeRule(anchor: RuleAnchor, recurs: boolean, prev: ScheduleRule, now: number, tz?: string): ScheduleRule;
+/** The reset instants a `window` rule is measured against. Passed in rather than
+ *  read, because this module has no clock and no host — see `nextFireAt`. */
+export interface WindowResets {
+    sessionResetAt?: number | null;
+    weeklyResetAt?: number | null;
+    /** 0..100 USED, as the CLI reports it. */
+    sessionPct?: number | null;
+    weeklyPct?: number | null;
+    /** Reset instants of the configured periods by id (`periodBounds(...).resetAt`,
+     *  computed by the caller). Read when a rule carries a `periodId`. */
+    periodResetAt?: Record<string, number | null | undefined>;
+}
+/** The reset this rule tracks, or `null` when the host has not read one yet. */
+export declare function windowResetAt(rule: ScheduleRule, r: WindowResets | undefined): number | null;
+/** The USED percentage for this rule's window, or `null` when unread. */
+export declare function windowPct(rule: ScheduleRule, r: WindowResets | undefined): number | null;
+/** The period id this rule's anchor tracks: its `periodId`, else its window. */
+export declare const anchorPeriodId: (rule: ScheduleRule) => string;
+/** The window this rule's ANCHOR tracks, with the same default `windowPct`
+ *  reads (`undefined` is the session window). */
+export declare const anchorWindow: (rule: ScheduleRule) => "session" | "weekly";
+/**
+ * **May this occurrence run?** — asked at FIRE time, never at arm time.
+ *
+ * The distinction is the whole feature. Arming happens once, hours ahead; the
+ * usage figure it would have been tested against is stale by the time the
+ * instant arrives, and the condition is precisely about what is true THEN. So
+ * `nextFireAt` places the occurrence and this decides, on the day, whether it
+ * is spent or skipped.
+ *
+ * **A reading it cannot get is a SKIP, not a run.** The opposite default is
+ * tempting — `budgetVerdict` fails OPEN for exactly this shape of input, and
+ * says why: it is scraped off a TUI and a parse broken upstream must not freeze
+ * every queue on every host. That argument does not transfer. The budget is a
+ * safety rail whose failure mode is "stop working"; this is a condition the
+ * user wrote to make work happen only when it is worth it, and firing a sweep
+ * across thirteen repos because nobody could read a percentage is the outcome
+ * they were trying to avoid. Failing closed here also cannot go silent: a skip
+ * is notified, so an unreadable meter surfaces as a sentence rather than as a
+ * schedule that quietly stopped mattering.
+ */
+export declare function windowCondition(rule: ScheduleRule, r: WindowResets | undefined): {
+    ok: boolean;
+    detail: string;
+};

package/node_modules/@waterplane/shared/dist/schedule/schedrule.js

@@ -0,0 +1,162 @@
+// Cut from schedule.ts (move only): the rule record, anchors and window conditions
+// The one door stays `./schedule.js`; this slice imports its siblings directly, never the barrel.
+/** How late a missed occurrence may still run, by default (minutes). Two hours:
+ *  long enough to survive a lunch-time sleep, short enough that a laptop opened
+ *  on Saturday doesn't fire Thursday's sweep. */
+export const DEFAULT_GRACE_MIN = 120;
+/** Weekday labels, index = `Date.getDay()`. */
+export const DAY_LABELS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+/** Which anchor. `once` and `weekly` are both clock-anchored; only `window`
+ *  tracks a usage reset instead of a time of day. */
+export function ruleAnchor(rule) {
+    return rule.kind === "window" ? "window" : "clock";
+}
+/**
+ * **Does this rule keep standing after it fires?** The one answer for
+ * "is this a schedule, or a thing that happens once" — the host's arm/settle
+ * logic, the schedule sheet's pause-vs-on/off split, and the verdict ladder's
+ * one-off branch all ask here rather than hand-rolling `kind !== "once"`,
+ * which stopped being a complete answer the day `oneShot` could apply to a
+ * `weekly` or `window` rule too.
+ */
+export function ruleRecurs(rule) {
+    if (rule.kind === "once")
+        return false;
+    return rule.oneShot !== true;
+}
+/**
+ * (anchor, recurrence) → a rule, carrying over whatever still means the same
+ * thing across the switch. The one encoder: a UI control renders the two
+ * questions as two toggles and never hand-rolls which `kind`/`oneShot` pair a
+ * choice maps to.
+ *
+ * `offsetMin` crosses anchors because it is a LEAD TIME in both: negative on a
+ * `weekly` rule and negative on a `before`-edge `window` rule mean the same
+ * thing ("fire this long ahead of the anchor"). A positive `window` `before`
+ * offset does not exist (`cleanRule` clamps it), so nothing is lost crossing
+ * the other way.
+ *
+ * `hours` crosses for a stronger reason: it is not about the anchor at all. "I
+ * am asleep between 22:00 and 07:00" stays true whichever instant the rule is
+ * hung off, and dropping it at the switch would silently re-open a door the
+ * user shut. `guardWindow` does NOT cross — it names one of two usage windows
+ * and means nothing on a wall clock — so it rides on `src` like `minPctLeft`,
+ * the field it exists to redirect.
+ */
+export function composeRule(anchor, recurs, prev, now, tz) {
+    // The window AND the zone it is expressed in, together on every kind: `hours`
+    // is minutes of day in `tz`, so a switch that carried the numbers and dropped
+    // the zone would re-read a 07:00–22:00 window against whatever clock the
+    // daemon happens to run on. `cleanRule` says the rest of why. The device's
+    // own zone is the fallback the sheet already passes in.
+    const zone = prev.tz || tz;
+    const only = prev.hours ? (zone ? { hours: prev.hours, tz: zone } : { hours: prev.hours }) : {};
+    if (anchor === "clock" && !recurs) {
+        return { kind: "once", at: prev.kind === "once" ? prev.at ?? now + 3600e3 : now + 3600e3, offsetMin: 0, ...only };
+    }
+    if (anchor === "clock") {
+        const src = prev.kind === "weekly" ? prev : undefined;
+        return {
+            kind: "weekly",
+            days: src?.days ?? [],
+            hour: src?.hour ?? 18,
+            minute: src?.minute ?? 0,
+            tz: src?.tz || tz,
+            offsetMin: prev.offsetMin ?? 0,
+            ...(recurs ? {} : { oneShot: true }),
+            ...only,
+        };
+    }
+    const src = prev.kind === "window" ? prev : undefined;
+    return {
+        kind: "window",
+        window: src?.window ?? "session",
+        ...(src?.periodId ? { periodId: src.periodId } : {}),
+        edge: src?.edge ?? "before",
+        offsetMin: src?.offsetMin ?? Math.min(0, prev.offsetMin ?? -60),
+        ...(src?.minPctLeft != null ? { minPctLeft: src.minPctLeft } : {}),
+        ...(src?.guardWindow ? { guardWindow: src.guardWindow } : {}),
+        ...(recurs ? {} : { oneShot: true }),
+        ...only,
+    };
+}
+/** The reset this rule tracks, or `null` when the host has not read one yet. */
+export function windowResetAt(rule, r) {
+    if (!r)
+        return null;
+    if (rule.periodId) {
+        const p = r.periodResetAt?.[rule.periodId];
+        return typeof p === "number" && p > 0 ? p : null;
+    }
+    const at = rule.window === "weekly" ? r.weeklyResetAt : r.sessionResetAt;
+    return typeof at === "number" && at > 0 ? at : null;
+}
+/** The USED percentage for this rule's window, or `null` when unread. */
+export function windowPct(rule, r) {
+    if (!r)
+        return null;
+    const p = rule.window === "weekly" ? r.weeklyPct : r.sessionPct;
+    return typeof p === "number" && Number.isFinite(p) ? p : null;
+}
+/** The period id this rule's anchor tracks: its `periodId`, else its window. */
+export const anchorPeriodId = (rule) => rule.periodId ?? (rule.window === "weekly" ? "weekly" : "session");
+/** The window this rule's ANCHOR tracks, with the same default `windowPct`
+ *  reads (`undefined` is the session window). */
+export const anchorWindow = (rule) => (rule.window === "weekly" ? "weekly" : "session");
+/** The window `minPctLeft` is tested against — the guard when one is named,
+ *  the anchor's own otherwise. One reading, so the condition, its sentence and
+ *  `describeRule` cannot disagree about which meter was read. */
+const guardOf = (rule) => rule.guardWindow ?? anchorWindow(rule);
+/**
+ * **May this occurrence run?** — asked at FIRE time, never at arm time.
+ *
+ * The distinction is the whole feature. Arming happens once, hours ahead; the
+ * usage figure it would have been tested against is stale by the time the
+ * instant arrives, and the condition is precisely about what is true THEN. So
+ * `nextFireAt` places the occurrence and this decides, on the day, whether it
+ * is spent or skipped.
+ *
+ * **A reading it cannot get is a SKIP, not a run.** The opposite default is
+ * tempting — `budgetVerdict` fails OPEN for exactly this shape of input, and
+ * says why: it is scraped off a TUI and a parse broken upstream must not freeze
+ * every queue on every host. That argument does not transfer. The budget is a
+ * safety rail whose failure mode is "stop working"; this is a condition the
+ * user wrote to make work happen only when it is worth it, and firing a sweep
+ * across thirteen repos because nobody could read a percentage is the outcome
+ * they were trying to avoid. Failing closed here also cannot go silent: a skip
+ * is notified, so an unreadable meter surfaces as a sentence rather than as a
+ * schedule that quietly stopped mattering.
+ */
+export function windowCondition(rule, r) {
+    if (rule.kind !== "window")
+        return { ok: true, detail: "" };
+    const guard = guardOf(rule);
+    // A window that has just reset is empty by definition — there is nothing to
+    // test, and a condition on `after` would only ever be a way to never run.
+    // That argument is about the window this rule is ANCHORED to and about no
+    // other: `guardWindow` naming the other one asks a question that has an
+    // answer at exactly this instant ("the session window is back — is there
+    // still a week's allowance to spend it out of?"), which is the whole reason
+    // the field exists. So the exemption is scoped to the same window, and lifts
+    // the moment the condition is about the other one.
+    if (rule.edge === "after" && guard === anchorWindow(rule))
+        return { ok: true, detail: "" };
+    const min = rule.minPctLeft;
+    if (min == null)
+        return { ok: true, detail: "" };
+    // Read the GUARD's meter, never the anchor's — the rule may be tracking one
+    // window's reset while asking about the other one's remainder.
+    const used = windowPct({ ...rule, window: guard }, r);
+    const name = guard === "weekly" ? "weekly" : "session";
+    if (used == null) {
+        return { ok: false, detail: `skipped — the ${name} usage could not be read, so the condition could not be checked` };
+    }
+    const left = Math.max(0, 100 - used);
+    if (left >= min)
+        return { ok: true, detail: `${Math.round(left)}% of the ${name} window was left` };
+    return {
+        ok: false,
+        detail: `skipped — conditions not met: ${Math.round(left)}% of the ${name} window was left, and this rule needs at least ${min}%`,
+    };
+}
+//# sourceMappingURL=schedrule.js.map

package/node_modules/@waterplane/shared/dist/schedule/schedrule.js.map

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

package/node_modules/@waterplane/shared/dist/schedule/schedtext.d.ts

@@ -0,0 +1,37 @@
+import { type ScheduleRule } from "./schedrule.js";
+/**
+ * **The name somebody TYPED, as opposed to a slice of their own prompt.**
+ *
+ * Nothing on this wire has a field for "is this a name or a derivation". Both
+ * ends fill the name slot the same way when no name was given: the host writes
+ * `action.text.split("\n")[0].slice(0, 120)` into `title` (`scheduleToIntent`)
+ * and back out into `ScheduleEntry.name` (`intentToSchedule`); `Backlog.add()`
+ * does the same at 40. So the overwhelming majority of names are a TRUNCATION of
+ * the text rendered two lines below them, and rendering both put one string on
+ * the card twice — cut once by the slice and again by CSS ellipsis, the header
+ * being the less useful of the two truncations. "already fi" over the sentence
+ * it was cut out of is not a title.
+ *
+ * The comparison is symmetric because either side may be the shorter one: the
+ * text starts with the name (the ordinary case), or the name starts with the
+ * text's own leading slice (a prompt shorter than `sliceLen`, where the slice
+ * took the whole first line and a multi-line prompt makes `t` the longer
+ * string). A name that survives both is a name.
+ *
+ * The empty-text guard is not a nicety: a build or a capture has no prose at
+ * all, and `n.startsWith("".slice(0, 120))` is vacuously true, so without it
+ * every such name would be reported as a truncation of nothing and no row would
+ * have a title left.
+ *
+ * `sliceLen` defaults to the host's 120; the backlog passes its own 40.
+ */
+export declare function typedName(name: string | null | undefined, text: string, sliceLen?: number): string | null;
+/** "2h", "45m", "1h 30m" — a lead/lag time in the smallest honest words. */
+export declare function fmtOffset(min: number): string;
+/**
+ * One line describing WHEN, in the terms the user set it: the anchor, its zone,
+ * and the lead time as a separate clause. Deliberately not the resolved fire
+ * clock — "16:00" hides the fact that the schedule is tracking an 18:00 reset,
+ * which is the thing that has to be edited when the reset moves.
+ */
+export declare function describeRule(rule: ScheduleRule): string;

package/node_modules/@waterplane/shared/dist/schedule/schedtext.js

@@ -0,0 +1,119 @@
+// Cut from schedule.ts (move only): describing a rule
+// The one door stays `./schedule.js`; this slice imports its siblings directly, never the barrel.
+import { DAY_LABELS, anchorPeriodId, anchorWindow } from "./schedrule.js";
+import { describeHours } from "./schedzone.js";
+/**
+ * **The name somebody TYPED, as opposed to a slice of their own prompt.**
+ *
+ * Nothing on this wire has a field for "is this a name or a derivation". Both
+ * ends fill the name slot the same way when no name was given: the host writes
+ * `action.text.split("\n")[0].slice(0, 120)` into `title` (`scheduleToIntent`)
+ * and back out into `ScheduleEntry.name` (`intentToSchedule`); `Backlog.add()`
+ * does the same at 40. So the overwhelming majority of names are a TRUNCATION of
+ * the text rendered two lines below them, and rendering both put one string on
+ * the card twice — cut once by the slice and again by CSS ellipsis, the header
+ * being the less useful of the two truncations. "already fi" over the sentence
+ * it was cut out of is not a title.
+ *
+ * The comparison is symmetric because either side may be the shorter one: the
+ * text starts with the name (the ordinary case), or the name starts with the
+ * text's own leading slice (a prompt shorter than `sliceLen`, where the slice
+ * took the whole first line and a multi-line prompt makes `t` the longer
+ * string). A name that survives both is a name.
+ *
+ * The empty-text guard is not a nicety: a build or a capture has no prose at
+ * all, and `n.startsWith("".slice(0, 120))` is vacuously true, so without it
+ * every such name would be reported as a truncation of nothing and no row would
+ * have a title left.
+ *
+ * `sliceLen` defaults to the host's 120; the backlog passes its own 40.
+ */
+export function typedName(name, text, sliceLen = 120) {
+    const n = (name ?? "").trim();
+    if (!n)
+        return null;
+    const t = (text ?? "").trim();
+    if (!t)
+        return n;
+    if (t.startsWith(n) || n.startsWith(t.slice(0, sliceLen)))
+        return null;
+    return n;
+}
+/** "2h", "45m", "1h 30m" — a lead/lag time in the smallest honest words. */
+export function fmtOffset(min) {
+    const abs = Math.abs(min);
+    const h = Math.floor(abs / 60);
+    const m = abs % 60;
+    if (h && m)
+        return `${h}h ${m}m`;
+    if (h)
+        return `${h}h`;
+    return `${m}m`;
+}
+/** Anchor wall clock as "HH:MM". */
+function hhmm(rule) {
+    return `${String(rule.hour ?? 0).padStart(2, "0")}:${String(rule.minute ?? 0).padStart(2, "0")}`;
+}
+/**
+ * One line describing WHEN, in the terms the user set it: the anchor, its zone,
+ * and the lead time as a separate clause. Deliberately not the resolved fire
+ * clock — "16:00" hides the fact that the schedule is tracking an 18:00 reset,
+ * which is the thing that has to be edited when the reset moves.
+ */
+export function describeRule(rule) {
+    const off = rule.offsetMin ?? 0;
+    const lead = off < 0 ? `, ${fmtOffset(off)} before` : off > 0 ? `, ${fmtOffset(off)} after` : "";
+    // The run window is a clause on EVERY kind, because it is a policy over the
+    // anchor rather than a part of one — and it goes last, after the anchor and
+    // its lead time, so the line still opens with the thing the rule tracks.
+    const only = describeHours(rule);
+    const hours = only ? `, only ${only}` : "";
+    if (rule.kind === "once") {
+        const at = rule.at ?? 0;
+        const when = new Date(at).toLocaleString(undefined, { weekday: "short", day: "numeric", month: "short", hour: "2-digit", minute: "2-digit" });
+        return `once · ${when}${lead}${hours}`;
+    }
+    // "once · " prefixes a one-shot `weekly`/`window` rule too, for the SAME
+    // reason it leads the `once`-kind branch above: the schedule sheet's section
+    // header is not sticky, so a card scrolled past it must say for itself
+    // whether it is standing policy or a thing that happens once.
+    const once = rule.oneShot === true ? "once · " : "";
+    if (rule.kind === "window") {
+        // Named by its ANCHOR, never by a resolved clock — the anchor is the thing
+        // that moves and the thing that has to be edited when it does.
+        // (wording kept local: `budget.ts`'s `periodWord` would close an import cycle through this slice)
+        const pid = anchorPeriodId(rule);
+        const w = pid === "weekly" ? "the weekly window" : pid === "session" ? "the session window" : pid === "rolling30d" ? "the rolling 30 days" : `the ${pid} period`;
+        // Which meter the condition reads is only worth saying when it is NOT the
+        // one the sentence already named: "2h before the session window resets,
+        // only if 40% is left" has one window in it and needs no second noun, while
+        // "right after the session window resets, only if 30% of the week is left"
+        // is two windows in one line and unreadable without it.
+        const guard = rule.guardWindow && rule.guardWindow !== anchorWindow(rule) ? rule.guardWindow : undefined;
+        const of = guard === "weekly" ? "of the week " : guard === "session" ? "of the session window " : "";
+        // An `after` edge carries a condition only when a guard lifted the
+        // "nothing to test" rule — `cleanRule` drops the pct otherwise, and this
+        // reads the same rule from the other side rather than trusting the field.
+        // A one-shot with a condition is kept until a reset meets it, and the
+        // sentence says so — "once, only if" would read as a single coin toss.
+        const cond = rule.minPctLeft != null && (rule.edge !== "after" || guard)
+            ? `, only if ${rule.minPctLeft}% ${of}is left${rule.oneShot === true ? " — else the next reset" : ""}` : "";
+        if (rule.edge === "after") {
+            return `${once}${off > 0 ? `${fmtOffset(off)} after ${w} resets` : `right after ${w} resets`}${cond}${hours}`;
+        }
+        return `${once}${off ? fmtOffset(off) : "0m"} before ${w} resets${cond}${hours}`;
+    }
+    // The KIND, said out loud, for the same reason `once` leads with "once ·":
+    // "Thu · 16:00" reads as a date, and the schedule sheet's card is the one
+    // place that has to distinguish standing policy from a thing that happens once
+    // — its section header is not sticky, so a card scrolled past it had nothing
+    // on it saying which kind it was. "every day" already did this; the day-list
+    // case did not. Nothing parses this string: it also feeds the host's
+    // notifications (`describeSchedule`) and `sendIntent.ts`, both prose.
+    // "every" contradicts the "once · " prefix, so a one-shot weekly rule reads
+    // "next" instead — same days/time/zone fields, the honest word for them.
+    const cadence = rule.oneShot === true ? "next" : "every";
+    const days = rule.days?.length ? `${cadence} ${rule.days.map((d) => DAY_LABELS[d] ?? "?").join(" ")}` : `${cadence} day`;
+    return `${once}${days} · ${hhmm(rule)}${rule.tz ? ` ${rule.tz}` : ""}${lead}${hours}`;
+}
+//# sourceMappingURL=schedtext.js.map

package/node_modules/@waterplane/shared/dist/schedule/schedtext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schedtext.js","sourceRoot":"","sources":["../../src/schedule/schedtext.ts"],"names":[],"mappings":"AAAA,sDAAsD;AACtD,kGAAkG;AAElG,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,YAAY,EAAqB,MAAM,gBAAgB,CAAC;AAC7F,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,SAAS,CAAC,IAA+B,EAAE,IAAY,EAAE,QAAQ,GAAG,GAAG;IACrF,MAAM,CAAC,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;IAC9B,IAAI,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IACpB,MAAM,CAAC,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;IAC9B,IAAI,CAAC,CAAC;QAAE,OAAO,CAAC,CAAC;IACjB,IAAI,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IACvE,OAAO,CAAC,CAAC;AACX,CAAC;AAED,4EAA4E;AAC5E,MAAM,UAAU,SAAS,CAAC,GAAW;IACnC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC1B,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,EAAE,CAAC,CAAC;IAC/B,MAAM,CAAC,GAAG,GAAG,GAAG,EAAE,CAAC;IACnB,IAAI,CAAC,IAAI,CAAC;QAAE,OAAO,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC;IACjC,IAAI,CAAC;QAAE,OAAO,GAAG,CAAC,GAAG,CAAC;IACtB,OAAO,GAAG,CAAC,GAAG,CAAC;AACjB,CAAC;AAED,oCAAoC;AACpC,SAAS,IAAI,CAAC,IAAkB;IAC9B,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC;AACnG,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,IAAkB;IAC7C,MAAM,GAAG,GAAG,IAAI,CAAC,SAAS,IAAI,CAAC,CAAC;IAChC,MAAM,IAAI,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;IACjG,4EAA4E;IAC5E,4EAA4E;IAC5E,yEAAyE;IACzE,MAAM,IAAI,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC;IACjC,MAAM,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IAC3C,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;QACzB,MAAM,EAAE,GAAG,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC;QACxB,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,EAAE,CAAC,CAAC,cAAc,CAAC,SAAS,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;QAC9I,OAAO,UAAU,IAAI,GAAG,IAAI,GAAG,KAAK,EAAE,CAAC;IACzC,CAAC;IACD,yEAAyE;IACzE,6EAA6E;IAC7E,uEAAuE;IACvE,8DAA8D;IAC9D,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC;IACpD,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC3B,2EAA2E;QAC3E,+DAA+D;QAC/D,kGAAkG;QAClG,MAAM,GAAG,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC;QACjC,MAAM,CAAC,GAAG,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC,CAAC,GAAG,KAAK,SAAS,CAAC,CAAC,CAAC,oBAAoB,CAAC,CAAC,CAAC,GAAG,KAAK,YAAY,CAAC,CAAC,CAAC,qBAAqB,CAAC,CAAC,CAAC,OAAO,GAAG,SAAS,CAAC;QACjK,0EAA0E;QAC1E,wEAAwE;QACxE,4EAA4E;QAC5E,2EAA2E;QAC3E,wDAAwD;QACxD,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,WAAW,KAAK,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC;QACzG,MAAM,EAAE,GAAG,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,wBAAwB,CAAC,CAAC,CAAC,EAAE,CAAC;QACrG,mEAAmE;QACnE,yEAAyE;QACzE,0EAA0E;QAC1E,sEAAsE;QACtE,uEAAuE;QACvE,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,KAAK,OAAO,IAAI,KAAK,CAAC;YACtE,CAAC,CAAC,aAAa,IAAI,CAAC,UAAU,KAAK,EAAE,UAAU,IAAI,CAAC,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,wBAAwB,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC9G,IAAI,IAAI,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;YAC1B,OAAO,GAAG,IAAI,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,eAAe,CAAC,SAAS,GAAG,IAAI,GAAG,KAAK,EAAE,CAAC;QAChH,CAAC;QACD,OAAO,GAAG,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,WAAW,CAAC,UAAU,IAAI,GAAG,KAAK,EAAE,CAAC;IACnF,CAAC;IACD,2EAA2E;IAC3E,0EAA0E;IAC1E,+EAA+E;IAC/E,6EAA6E;IAC7E,6EAA6E;IAC7E,qEAAqE;IACrE,sEAAsE;IACtE,4EAA4E;IAC5E,yEAAyE;IACzE,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC;IACzD,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,OAAO,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,OAAO,MAAM,CAAC;IACzH,OAAO,GAAG,IAAI,GAAG,IAAI,MAAM,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,GAAG,KAAK,EAAE,CAAC;AACxF,CAAC"}

package/node_modules/@waterplane/shared/dist/schedule/schedwhen.d.ts

@@ -0,0 +1,54 @@
+import type { ScheduleRule } from "./schedrule.js";
+/** An instant in the reader's locale: "Tue 1 Oct, 14:00". On the host it is the
+ *  desktop's locale and zone — the same machine the agent asking runs on. */
+export declare const fmtWhen: (t: number) => string;
+/**
+ * "in 3d 4h" / "in 12m" / "due now". Relative is what a waiting row is read for.
+ *
+ * `now` is a parameter with a default rather than a bare `Date.now()` so a
+ * caller that already froze a clock for the whole render can hand it over —
+ * `backlogFilter.ts`'s `clockWords` does, because a sentence a `node --test`
+ * has to pin cannot read the wall clock, and because two readings of the clock
+ * inside one row is how "in 60m" sits under a chip saying "in 59m".
+ */
+export declare function inWords(t: number, now?: number): string;
+/**
+ * A chain, as one short clause — the *When* row's collapsed line, and the tail
+ * of the primary button's sentence.
+ *
+ * The title is quoted because it is somebody else's words appearing inside
+ * ours, and it is the same reason `shared/intent.ts` quotes it in the sentence
+ * the waiting row then wears. Absent, the clause names no title rather than a
+ * placeholder: a row that says "the item before it" is vague, and a row that
+ * invents a name is wrong, and only one of those can be fixed by looking.
+ *
+ * `onlyIfOk` belongs in the same clause rather than in a second line, because
+ * the *When* row is read at a glance and "after X" and "after X, but only if X
+ * worked" are two different instructions, not one instruction with a detail.
+ */
+export declare function afterWords(title?: string, onlyIfOk?: boolean): string;
+/** The WHEN half of a send, structurally — the web's `SendWhen` is one of
+ *  these, and so is what the agent route reads off a posted row. */
+export type WhenShape = {
+    kind: "now";
+} | {
+    kind: "idle";
+} | {
+    kind: "after";
+    title?: string;
+    onlyIfOk?: boolean;
+} | {
+    kind: "at";
+    rule: ScheduleRule;
+};
+/**
+ * The *When* row's own words. `preview` is the resolved instant for an `at`.
+ *
+ * **No preview is two different facts and they must not share a sentence.** A
+ * `once` rule with nothing ahead of it HAS a time and it is behind us. A
+ * `window` rule has no clock at all until the host has read the usage meter
+ * once — that is the normal state of a freshly written rule, said on this very
+ * screen ("Nothing is armed until the host has read the window once"), and
+ * calling it "never" told the user their schedule was dead on arrival.
+ */
+export declare function whenWords(w: WhenShape, preview: number | null): string;