@upnextapp/core 0.19.0 → 0.21.0

package/dist/cjs/activeHours.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTimeOfDayOutsideActiveHours = isTimeOfDayOutsideActiveHours;
+function isTimeOfDayOutsideActiveHours(startDateTime, activeStart, activeEnd) {
+    if (!startDateTime)
+        return false;
+    const start = new Date(startDateTime);
+    if (Number.isNaN(start.getTime()))
+        return false;
+    const startMinutes = start.getHours() * 60 + start.getMinutes();
+    const [aSH, aSM] = activeStart.split(':').map(Number);
+    const [aEH, aEM] = activeEnd.split(':').map(Number);
+    if (Number.isNaN(aSH) || Number.isNaN(aSM) || Number.isNaN(aEH) || Number.isNaN(aEM))
+        return false;
+    const startMin = aSH * 60 + aSM;
+    const endMin = aEH * 60 + aEM;
+    const isLegacyMidnightWrap = (aEH === 0 && aEM === 0);
+    const isInverted = !isLegacyMidnightWrap && startMin > endMin;
+    if (isLegacyMidnightWrap) {
+        return startMinutes < startMin;
+    }
+    if (isInverted) {
+        // Note: for inverted windows the engine's firstSlotForDay would CLAMP a daytime
+        // anchor into the window (e.g. 12:00 daily → fires 22:00). Forms intentionally
+        // treat daytime anchors as outside so saves are blocked — silently moving a
+        // user's chosen time by 10 hours would be a footgun. This is deliberate
+        // form-stricter-than-engine behavior, not drift.
+        return startMinutes > endMin && startMinutes < startMin;
+    }
+    return startMinutes < startMin || startMinutes > endMin;
+}

package/dist/cjs/coarsenIdleTime.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IDLE_TIME_BUCKET_SECONDS = void 0;
+exports.coarsenIdleTime = coarsenIdleTime;
+exports.IDLE_TIME_BUCKET_SECONDS = 15;
+function coarsenIdleTime(seconds) {
+    return Math.floor(seconds / exports.IDLE_TIME_BUCKET_SECONDS) * exports.IDLE_TIME_BUCKET_SECONDS;
+}

package/dist/cjs/formatNextTrigger.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatNextTrigger = formatNextTrigger;
+function formatNextTrigger(ts, now = Date.now()) {
+    if (!ts || ts <= 0)
+        return 'N/A';
+    const date = new Date(ts);
+    const currentDate = new Date(now);
+    const isToday = date.toDateString() === currentDate.toDateString();
+    const time = date.toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit' });
+    if (isToday)
+        return `Today ${time}`;
+    return date.toLocaleDateString('en-US', { month: 'short', day: 'numeric', hour: 'numeric', minute: '2-digit' });
+}

package/dist/cjs/index.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pluginManifestSchema = exports.validatePluginManifest = exports.shouldAutoClose = exports.isNewer = exports.versionSatisfies = exports.buildSignedPayload = exports.isPastOnce = exports.isEnded = exports.badgeFor = exports.formatNextTrigger = exports.IDLE_TIME_BUCKET_SECONDS = exports.coarsenIdleTime = exports.isTimeOfDayOutsideActiveHours = exports.STALE_ACTIVE_THRESHOLD_MS = exports.todaySlotTime = exports.isOccurrenceOverdue = exports.isStaleActive = exports.shouldTriggerOnDay = exports.matchesRecurrenceInterval = exports.isWithinActiveHours = exports.firstSlotForDay = exports.calculateNextTriggerFromNow = exports.calculateNextTrigger = exports.authorityOverride = void 0;
+var writeAuthority_js_1 = require("./writeAuthority.js");
+Object.defineProperty(exports, "authorityOverride", { enumerable: true, get: function () { return writeAuthority_js_1.authorityOverride; } });
+var scheduling_js_1 = require("./scheduling.js");
+Object.defineProperty(exports, "calculateNextTrigger", { enumerable: true, get: function () { return scheduling_js_1.calculateNextTrigger; } });
+Object.defineProperty(exports, "calculateNextTriggerFromNow", { enumerable: true, get: function () { return scheduling_js_1.calculateNextTriggerFromNow; } });
+Object.defineProperty(exports, "firstSlotForDay", { enumerable: true, get: function () { return scheduling_js_1.firstSlotForDay; } });
+Object.defineProperty(exports, "isWithinActiveHours", { enumerable: true, get: function () { return scheduling_js_1.isWithinActiveHours; } });
+Object.defineProperty(exports, "matchesRecurrenceInterval", { enumerable: true, get: function () { return scheduling_js_1.matchesRecurrenceInterval; } });
+Object.defineProperty(exports, "shouldTriggerOnDay", { enumerable: true, get: function () { return scheduling_js_1.shouldTriggerOnDay; } });
+Object.defineProperty(exports, "isStaleActive", { enumerable: true, get: function () { return scheduling_js_1.isStaleActive; } });
+Object.defineProperty(exports, "isOccurrenceOverdue", { enumerable: true, get: function () { return scheduling_js_1.isOccurrenceOverdue; } });
+Object.defineProperty(exports, "todaySlotTime", { enumerable: true, get: function () { return scheduling_js_1.todaySlotTime; } });
+Object.defineProperty(exports, "STALE_ACTIVE_THRESHOLD_MS", { enumerable: true, get: function () { return scheduling_js_1.STALE_ACTIVE_THRESHOLD_MS; } });
+var activeHours_js_1 = require("./activeHours.js");
+Object.defineProperty(exports, "isTimeOfDayOutsideActiveHours", { enumerable: true, get: function () { return activeHours_js_1.isTimeOfDayOutsideActiveHours; } });
+var coarsenIdleTime_js_1 = require("./coarsenIdleTime.js");
+Object.defineProperty(exports, "coarsenIdleTime", { enumerable: true, get: function () { return coarsenIdleTime_js_1.coarsenIdleTime; } });
+Object.defineProperty(exports, "IDLE_TIME_BUCKET_SECONDS", { enumerable: true, get: function () { return coarsenIdleTime_js_1.IDLE_TIME_BUCKET_SECONDS; } });
+var formatNextTrigger_js_1 = require("./formatNextTrigger.js");
+Object.defineProperty(exports, "formatNextTrigger", { enumerable: true, get: function () { return formatNextTrigger_js_1.formatNextTrigger; } });
+var reminderBadges_js_1 = require("./reminderBadges.js");
+Object.defineProperty(exports, "badgeFor", { enumerable: true, get: function () { return reminderBadges_js_1.badgeFor; } });
+Object.defineProperty(exports, "isEnded", { enumerable: true, get: function () { return reminderBadges_js_1.isEnded; } });
+Object.defineProperty(exports, "isPastOnce", { enumerable: true, get: function () { return reminderBadges_js_1.isPastOnce; } });
+var integrityPayload_js_1 = require("./integrityPayload.js");
+Object.defineProperty(exports, "buildSignedPayload", { enumerable: true, get: function () { return integrityPayload_js_1.buildSignedPayload; } });
+var semver_js_1 = require("./semver.js");
+Object.defineProperty(exports, "versionSatisfies", { enumerable: true, get: function () { return semver_js_1.versionSatisfies; } });
+Object.defineProperty(exports, "isNewer", { enumerable: true, get: function () { return semver_js_1.isNewer; } });
+var shouldAutoClose_js_1 = require("./shouldAutoClose.js");
+Object.defineProperty(exports, "shouldAutoClose", { enumerable: true, get: function () { return shouldAutoClose_js_1.shouldAutoClose; } });
+var manifest_js_1 = require("./manifest.js");
+Object.defineProperty(exports, "validatePluginManifest", { enumerable: true, get: function () { return manifest_js_1.validatePluginManifest; } });
+Object.defineProperty(exports, "pluginManifestSchema", { enumerable: true, get: function () { return manifest_js_1.pluginManifestSchema; } });

package/dist/cjs/integrityPayload.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSignedPayload = buildSignedPayload;
+// CANONICAL source of buildSignedPayload. The inline copy in scripts/sign-plugin.mjs
+// MUST stay byte-for-byte in sync. Drift = plugin signature verification breaks.
+// Sync test: src/tests/unit/integrityPayload.test.ts 'sign-plugin.mjs sync check'
+function buildSignedPayload(pluginId, version, entryPath, entrySha256) {
+    return `${pluginId}:${version}:${entryPath}:${entrySha256}`;
+}

package/dist/cjs/manifest.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pluginManifestSchema = void 0;
+exports.validatePluginManifest = validatePluginManifest;
+const zod_1 = require("zod");
+const windowConfigSchema = zod_1.z.object({
+    id: zod_1.z.string().min(1),
+    size: zod_1.z.object({
+        width: zod_1.z.number().positive(),
+        height: zod_1.z.union([zod_1.z.number().positive(), zod_1.z.literal('full')]),
+    }),
+    position: zod_1.z.enum(['center', 'right-edge', 'left-edge']).optional(),
+    frameless: zod_1.z.boolean().optional(),
+    alwaysOnTop: zod_1.z.boolean().optional(),
+    persistent: zod_1.z.boolean().optional(),
+    skipTaskbar: zod_1.z.boolean().optional(),
+});
+const pageConfigSchema = zod_1.z.object({
+    id: zod_1.z.string().min(1),
+    label: zod_1.z.string(),
+    icon: zod_1.z.string(),
+});
+exports.pluginManifestSchema = zod_1.z.object({
+    id: zod_1.z.string().min(1).regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/, 'Plugin IDs may only contain letters, digits, dots, underscores, and hyphens').refine(id => !id.startsWith('__'), 'Plugin IDs cannot start with __'),
+    name: zod_1.z.string().min(1),
+    version: zod_1.z.string().regex(/^\d+\.\d+\.\d+$/),
+    description: zod_1.z.string().optional(),
+    author: zod_1.z.string().optional(),
+    icon: zod_1.z.string().optional(),
+    color: zod_1.z.string().optional(),
+    minPlatformVersion: zod_1.z.string().optional(),
+    capabilities: zod_1.z.array(zod_1.z.string()).default([]),
+    client: zod_1.z.object({
+        entry: zod_1.z.string().min(1).refine(e => !e.includes('..') && !e.startsWith('/'), {
+            message: 'Entry path must not contain ".." or start with "/"',
+        }),
+        pages: zod_1.z.array(pageConfigSchema).default([]),
+        windows: zod_1.z.array(windowConfigSchema).default([]),
+        reminderTypes: zod_1.z.array(zod_1.z.string()).default([]),
+        settingsPanel: zod_1.z.boolean().optional(),
+        componentMap: zod_1.z.record(zod_1.z.string().regex(/^(pages|windows|edit|css):[a-zA-Z0-9_-]+$/, 'componentMap keys must follow pattern "category:id" where category is pages, windows, edit, or css'), zod_1.z.string().min(1).refine(e => !e.includes('..') && !e.startsWith('/'), {
+            message: 'Path must not contain ".." or start with "/"',
+        })).optional(),
+    }),
+    server: zod_1.z
+        .object({
+        entry: zod_1.z.string().min(1).refine(e => !e.includes('..') && !e.startsWith('/'), {
+            message: 'Entry path must not contain ".." or start with "/"',
+        }),
+        routes: zod_1.z.array(zod_1.z.any()).default([]),
+        webhooks: zod_1.z.array(zod_1.z.any()).default([]),
+        cronJobs: zod_1.z.array(zod_1.z.any()).default([]),
+        tables: zod_1.z.array(zod_1.z.string()).default([]),
+        env: zod_1.z.array(zod_1.z.string()).default([]),
+    })
+        .optional(),
+});
+function validatePluginManifest(data) {
+    return exports.pluginManifestSchema.safeParse(data);
+}

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/cjs/reminderBadges.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEnded = isEnded;
+exports.isPastOnce = isPastOnce;
+exports.badgeFor = badgeFor;
+const formatNextTrigger_js_1 = require("./formatNextTrigger.js");
+function isEnded(def, now = Date.now()) {
+    return def.endTime != null && now >= new Date(def.endTime).getTime();
+}
+function isPastOnce(def, now = Date.now()) {
+    return def.recurrenceType === 'once' && new Date(def.startDateTime).getTime() < now;
+}
+function badgeFor(def, reminder, dockedDefIds, now = Date.now()) {
+    if (isEnded(def, now))
+        return { label: 'Ended', tone: 'done' };
+    if (!reminder) {
+        return isPastOnce(def, now) ? { label: 'Done', tone: 'done' } : null;
+    }
+    if (reminder.status === 'active') {
+        return dockedDefIds.has(def.id) ? { label: 'Docked', tone: 'docked' } : { label: 'Active', tone: 'active' };
+    }
+    if (reminder.status === 'delayed') {
+        const until = (0, formatNextTrigger_js_1.formatNextTrigger)(reminder.delayUntil && reminder.delayUntil > 0 ? reminder.delayUntil : reminder.nextTriggerTime, now);
+        return until === 'N/A' ? { label: 'Snoozed', tone: 'snoozed' } : { label: `Snoozed until ${until}`, tone: 'snoozed' };
+    }
+    if (reminder.status === 'completed')
+        return { label: 'Done', tone: 'done' };
+    return null;
+}

package/dist/cjs/scheduling.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STALE_ACTIVE_THRESHOLD_MS = void 0;
+exports.shouldTriggerOnDay = shouldTriggerOnDay;
+exports.todaySlotTime = todaySlotTime;
+exports.isWithinActiveHours = isWithinActiveHours;
+exports.matchesRecurrenceInterval = matchesRecurrenceInterval;
+exports.calculateNextTrigger = calculateNextTrigger;
+exports.firstSlotForDay = firstSlotForDay;
+exports.calculateNextTriggerFromNow = calculateNextTriggerFromNow;
+exports.isStaleActive = isStaleActive;
+exports.isOccurrenceOverdue = isOccurrenceOverdue;
+exports.STALE_ACTIVE_THRESHOLD_MS = 48 * 60 * 60 * 1000;
+function shouldTriggerOnDay(def, date) {
+    if (!def.daysOfWeek || def.daysOfWeek.length === 0)
+        return true;
+    const dayOfWeek = date.getDay();
+    return def.daysOfWeek.includes(dayOfWeek);
+}
+// Today's occurrence slot for a def: the anchor's LOCAL wall-clock hour:minute
+// (from startDateTime) applied to `now`'s calendar day, seconds/ms zeroed.
+// Wall-clock-local by design (mirrors firstSlotForDay's non-hourly anchor):
+// absolute-ms math drifts +1h across DST transitions. Consumers: the engine's
+// missed-occurrence gates and the creation loop's due-ness check — a single
+// source so the gates can never drift from settle's due-ness.
+function todaySlotTime(def, now) {
+    const startTime = new Date(def.startDateTime);
+    const todayScheduled = new Date(now);
+    todayScheduled.setHours(startTime.getHours(), startTime.getMinutes(), 0, 0);
+    return todayScheduled.getTime();
+}
+function isWithinActiveHours(now, startTime, endTime) {
+    const date = new Date(now);
+    const [startH, startM] = startTime.split(':').map(Number);
+    const [endH, endM] = endTime.split(':').map(Number);
+    if (Number.isNaN(startH) || Number.isNaN(startM) || Number.isNaN(endH) || Number.isNaN(endM)) {
+        return false;
+    }
+    const start = new Date(date);
+    start.setHours(startH, startM, 0, 0);
+    const end = new Date(date);
+    const isLegacyMidnightWrap = (endH === 0 && endM === 0);
+    const isInverted = !isLegacyMidnightWrap && (startH * 60 + startM) > (endH * 60 + endM);
+    if (isLegacyMidnightWrap || isInverted) {
+        end.setDate(end.getDate() + 1);
+    }
+    end.setHours(endH, endM, 0, 0);
+    if (isInverted && now < start.getTime()) {
+        start.setDate(start.getDate() - 1);
+        end.setDate(end.getDate() - 1);
+    }
+    return now >= start.getTime() && now <= end.getTime();
+}
+function matchesRecurrenceInterval(def, day, startDate, anchorDayStartMs) {
+    const interval = def.interval && def.interval > 0 ? def.interval : 1;
+    const dayStart = new Date(day);
+    dayStart.setHours(0, 0, 0, 0);
+    const dayDiffMs = dayStart.getTime() - anchorDayStartMs;
+    if (dayDiffMs < 0)
+        return false;
+    switch (def.recurrenceType) {
+        case 'hourly':
+            return true;
+        case 'daily': {
+            const dayDiff = Math.floor(dayDiffMs / (24 * 60 * 60 * 1000));
+            return dayDiff % interval === 0;
+        }
+        case 'weekly': {
+            const weekDiff = Math.floor(dayDiffMs / (7 * 24 * 60 * 60 * 1000));
+            return weekDiff % interval === 0;
+        }
+        case 'monthly': {
+            const monthDiff = (day.getFullYear() - startDate.getFullYear()) * 12 + (day.getMonth() - startDate.getMonth());
+            return monthDiff >= 0 && monthDiff % interval === 0 && day.getDate() === startDate.getDate();
+        }
+        case 'yearly': {
+            const yearDiff = day.getFullYear() - startDate.getFullYear();
+            return yearDiff >= 0 && yearDiff % interval === 0
+                && day.getMonth() === startDate.getMonth() && day.getDate() === startDate.getDate();
+        }
+        default:
+            return true;
+    }
+}
+function calculateNextTrigger(def, fromTime, activeStart, activeEnd) {
+    if (!def.enabled)
+        return null;
+    const startMs = new Date(def.startDateTime).getTime();
+    if (def.recurrenceType === 'once') {
+        return startMs > fromTime ? startMs : null;
+    }
+    if (def.endTime && fromTime >= new Date(def.endTime).getTime())
+        return null;
+    const startDate = new Date(def.startDateTime);
+    const fromDate = new Date(fromTime);
+    fromDate.setHours(0, 0, 0, 0);
+    const anchorDayStart = new Date(def.startDateTime);
+    anchorDayStart.setHours(0, 0, 0, 0);
+    const anchorDayStartMs = anchorDayStart.getTime();
+    const interval = def.interval && def.interval > 0 ? def.interval : 1;
+    let maxDays = 400;
+    if (def.recurrenceType === 'yearly')
+        maxDays = Math.max(maxDays, interval * 366 * 4 + 10);
+    else if (def.recurrenceType === 'monthly')
+        maxDays = Math.max(maxDays, interval * 31 + 10);
+    for (let offset = 0; offset <= maxDays; offset++) {
+        const day = new Date(fromDate);
+        day.setDate(day.getDate() + offset);
+        // Empty daysOfWeek = no filter (fires every day). UI prevents empty array on save.
+        // If this assumption changes, add explicit guard for length === 0.
+        if (def.daysOfWeek && def.daysOfWeek.length > 0 && !def.daysOfWeek.includes(day.getDay()))
+            continue;
+        if (!matchesRecurrenceInterval(def, day, startDate, anchorDayStartMs))
+            continue;
+        const slot = firstSlotForDay(def, day, startMs, activeStart, activeEnd, fromTime);
+        if (slot !== null) {
+            if (def.endTime && slot >= new Date(def.endTime).getTime())
+                return null;
+            return slot;
+        }
+    }
+    return null;
+}
+// Supports inverted active hours (activeStart > activeEnd, e.g. night shift 22:00-06:00).
+// When inverted, boundsEnd wraps to the next day, producing an overnight window
+// [activeStart today, activeEnd tomorrow]. For non-hourly recurrences, an anchor whose
+// time-of-day falls in the early-morning portion of the inverted window ([00:00, activeEnd))
+// is shifted to the next day so the slot lands inside the window.
+function firstSlotForDay(def, day, anchorInstant, activeStart, activeEnd, fromTime) {
+    const [aSH, aSM] = activeStart.split(':').map(Number);
+    const [aEH, aEM] = activeEnd.split(':').map(Number);
+    if (Number.isNaN(aSH) || Number.isNaN(aSM) || Number.isNaN(aEH) || Number.isNaN(aEM)) {
+        return null;
+    }
+    const boundsStart = new Date(day);
+    boundsStart.setHours(aSH, aSM, 0, 0);
+    const boundsEnd = new Date(day);
+    boundsEnd.setHours(aEH, aEM, 0, 0);
+    const isLegacyMidnightWrap = (aEH === 0 && aEM === 0);
+    const startTodMin = aSH * 60 + aSM;
+    const endTodMin = aEH * 60 + aEM;
+    const isInverted = !isLegacyMidnightWrap && startTodMin > endTodMin;
+    if (isLegacyMidnightWrap || isInverted) {
+        boundsEnd.setDate(boundsEnd.getDate() + 1);
+    }
+    if (def.recurrenceType === 'hourly') {
+        const intervalHours = (def.interval && def.interval > 0 ? def.interval : 1);
+        // Hourly: strict > prevents re-firing at the same instant as a recent dismissal
+        const lowerBound = Math.max(boundsStart.getTime(), fromTime + 1);
+        if (lowerBound > boundsEnd.getTime())
+            return null;
+        // Grid phase anchored to LOCAL hour:minute of startDateTime (not absolute UTC ms).
+        // Absolute-ms grids drift across DST: an anchor saved during standard time displays
+        // +1h during daylight time because UTC offset changes. Reading hour:minute directly
+        // from the startDateTime string (format "YYYY-MM-DDTHH:mm") is TZ-independent —
+        // it's the literal wall-clock hour the user chose.
+        const timePart = def.startDateTime.split('T')[1] ?? '00:00';
+        const [aH, aM] = timePart.split(':').map(Number);
+        const anchorTodMin = (Number.isNaN(aH) ? 0 : aH) * 60 + (Number.isNaN(aM) ? 0 : aM);
+        const intervalMin = intervalHours * 60;
+        const slotStart = new Date(boundsStart);
+        const boundsStartTodMin = slotStart.getHours() * 60 + slotStart.getMinutes();
+        const phaseOffset = ((anchorTodMin - boundsStartTodMin) % intervalMin + intervalMin) % intervalMin;
+        slotStart.setMinutes(slotStart.getMinutes() + phaseOffset, 0, 0);
+        // setHours advances wall-clock hour by intervalHours — DST transitions are handled
+        // correctly (slots stay at consistent local hour regardless of UTC offset changes).
+        while (slotStart.getTime() < lowerBound) {
+            slotStart.setHours(slotStart.getHours() + intervalHours);
+        }
+        if (slotStart.getTime() > boundsEnd.getTime())
+            return null;
+        return slotStart.getTime();
+    }
+    const anchorDate = new Date(anchorInstant);
+    const anchorTodMin = anchorDate.getHours() * 60 + anchorDate.getMinutes();
+    const anchorDay = new Date(day);
+    if (isInverted && anchorTodMin < endTodMin) {
+        anchorDay.setDate(anchorDay.getDate() + 1);
+    }
+    const anchor = new Date(anchorDay);
+    anchor.setHours(anchorDate.getHours(), anchorDate.getMinutes(), 0, 0);
+    const anchorMs = anchor.getTime();
+    if (anchorMs > boundsEnd.getTime())
+        return null;
+    const effective = Math.max(anchorMs, boundsStart.getTime());
+    // Daily/weekly/etc: inclusive >= because same-instant re-fire is extremely unlikely (24h+ intervals).
+    // NOTE: edge case where fromTime exactly equals anchor (e.g. startup at scheduled fire time) DOES
+    // re-fire — intentional, ensures missed-on-startup triggers still activate.
+    return effective >= fromTime ? effective : null;
+}
+function calculateNextTriggerFromNow(def, fromTime, activeStart, activeEnd) {
+    if (!def.enabled)
+        return null;
+    if (def.recurrenceType === 'once')
+        return null;
+    return calculateNextTrigger(def, fromTime, activeStart, activeEnd);
+}
+function isStaleActive(reminder, now, def) {
+    // Single 48h threshold for every recurrence type, aligned with the server's P3
+    // progression floor (sync_lww_guard) and writeAuthority.ts — the sweep fires only
+    // when the server would accept the dismissal, so attempts succeed first try.
+    // Keyed to activated_at — the alive-as-active clock — because updated_at is
+    // re-stamped by every plugin tick, which starved the sweep on ticking rows (Obs 3).
+    // Legacy rows with a null activated_at fall back to updated_at (server COALESCE).
+    // def is retained for signature compatibility.
+    void def;
+    const aliveAsActiveAt = reminder.activatedAt ?? reminder.updatedAt;
+    if (aliveAsActiveAt == null)
+        return true;
+    return (now - aliveAsActiveAt) > exports.STALE_ACTIVE_THRESHOLD_MS;
+}
+function isOccurrenceOverdue(def, reminder, now, activeStart, activeEnd) {
+    // Auto-advance only when the next due slot is on a NEW calendar day than the
+    // current occurrence's slot. daily/weekly/monthly/yearly always cross days
+    // (so they reset each occurrence); hourly reminders keep escalating through
+    // same-day slots and only reset at the first slot after midnight. Because a
+    // recurring reminder always crosses a day within ~24h, this fires well before
+    // the 48h stale path above — so stale dismissal only reaches `once`/docked.
+    //
+    // Pass nextTriggerTime + 1: firstSlotForDay uses inclusive >= for non-hourly (so startup
+    // at exact fire-time re-fires missed triggers). Without +1 here, calculateNextTrigger
+    // would return the SAME slot, making this day-comparison always equal → no auto-advance.
+    // Note: +1 is only effective for non-hourly types; hourly already uses fromTime+1 internally,
+    // so this becomes a double-offset that Math.ceil absorbs (no slot skip).
+    const nextSlot = calculateNextTrigger(def, reminder.nextTriggerTime + 1, activeStart, activeEnd);
+    if (nextSlot === null || now < nextSlot)
+        return false;
+    return new Date(nextSlot).toDateString() !== new Date(reminder.nextTriggerTime).toDateString();
+}

package/dist/cjs/semver.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.versionSatisfies = versionSatisfies;
+exports.isNewer = isNewer;
+function versionSatisfies(appVersion, minVersion) {
+    if (!minVersion)
+        return true;
+    const app = appVersion.split('.').map(Number);
+    const min = minVersion.split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        const a = app[i] ?? 0;
+        const m = min[i] ?? 0;
+        if (Number.isNaN(a) || Number.isNaN(m))
+            return false;
+        if (a < m)
+            return false;
+        if (a > m)
+            return true;
+    }
+    return true;
+}
+function isNewer(current, candidate) {
+    const cur = current.split('.').map(Number);
+    const cand = candidate.split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        const c = cand[i] ?? 0;
+        const v = cur[i] ?? 0;
+        if (Number.isNaN(c) || Number.isNaN(v))
+            return false;
+        if (c > v)
+            return true;
+        if (c < v)
+            return false;
+    }
+    return false;
+}

package/dist/cjs/shouldAutoClose.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldAutoClose = shouldAutoClose;
+function shouldAutoClose(expanded, dragHighlight, lastInteraction, now, thresholdMs = 5000) {
+    return expanded && !dragHighlight && (now - lastInteraction) > thresholdMs;
+}

package/dist/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/writeAuthority.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authorityOverride = authorityOverride;
+const scheduling_js_1 = require("./scheduling.js");
+// Matches the server's jsonb BIGINT casts: NULL/missing coerces to 0.
+function stamp(value) {
+    return Number(value) || 0;
+}
+// Client mirror of sync_lww_guard (supabase/migrations/20260920200000_p3_staleness_activation.sql):
+// incoming user over local auto always wins; incoming auto over local user wins only via a
+// progression rule — the user's own data says it's time:
+//   P1 delayed -> active once the user-set delay_until has passed
+//   P2 completed -> scheduled/active with a strictly LATER next_trigger_time (forward rebook only)
+//   P3 active -> scheduled/completed once the row is 48h stale by activated_at — the
+//      alive-as-active clock, falling back to updated_at when activated_at is NULL (legacy
+//      rows). updated_at alone is wrong: ticking plugins re-stamp it every tick, which
+//      starved the sweep on actively-ticking rows (Obs 3).
+//   P4 scheduled -> active once the user-scheduled next_trigger_time has arrived (the fire)
+// Returns null when kinds match so the caller falls back to updated_at comparison.
+// Missing kinds default to 'auto' (S9: pre-migration rows, old clients).
+function authorityOverride(local, incoming, now) {
+    const localKind = local.writeKind ?? 'auto';
+    const incomingKind = incoming.writeKind ?? 'auto';
+    if (localKind === incomingKind)
+        return null;
+    if (incomingKind === 'user')
+        return true;
+    if (local.status === 'delayed'
+        && incoming.status === 'active'
+        && stamp(local.delayUntil) <= now)
+        return true;
+    if (local.status === 'completed'
+        && (incoming.status === 'scheduled' || incoming.status === 'active')
+        && stamp(incoming.nextTriggerTime) > stamp(local.nextTriggerTime))
+        return true;
+    if (local.status === 'active'
+        && (incoming.status === 'scheduled' || incoming.status === 'completed')
+        && stamp(local.activatedAt ?? local.updatedAt) <= now - scheduling_js_1.STALE_ACTIVE_THRESHOLD_MS)
+        return true;
+    if (local.status === 'scheduled'
+        && incoming.status === 'active'
+        && stamp(local.nextTriggerTime) <= now)
+        return true;
+    return false;
+}

package/dist/index.d.ts

@@ -1,10 +1,12 @@
 export type { ReminderStatus, ScheduledReminder, RecurrenceType, ResponsibilityDef, AppSettings, StoreSchema, WriteKind } from './types.js';
 export { authorityOverride } from './writeAuthority.js';
 export type { AuthorityRow } from './writeAuthority.js';
-export { calculateNextTrigger, calculateNextTriggerFromNow, firstSlotForDay, isWithinActiveHours, matchesRecurrenceInterval, shouldTriggerOnDay, isStaleActive, isOccurrenceOverdue, STALE_ACTIVE_THRESHOLD_MS } from './scheduling.js';
+export { calculateNextTrigger, calculateNextTriggerFromNow, firstSlotForDay, isWithinActiveHours, matchesRecurrenceInterval, shouldTriggerOnDay, isStaleActive, isOccurrenceOverdue, todaySlotTime, STALE_ACTIVE_THRESHOLD_MS } from './scheduling.js';
 export { isTimeOfDayOutsideActiveHours } from './activeHours.js';
 export { coarsenIdleTime, IDLE_TIME_BUCKET_SECONDS } from './coarsenIdleTime.js';
 export { formatNextTrigger } from './formatNextTrigger.js';
+export { badgeFor, isEnded, isPastOnce } from './reminderBadges.js';
+export type { ReminderBadge, ReminderBadgeTone } from './reminderBadges.js';
 export { buildSignedPayload } from './integrityPayload.js';
 export { versionSatisfies, isNewer } from './semver.js';
 export { shouldAutoClose } from './shouldAutoClose.js';

package/dist/index.js

@@ -1,8 +1,9 @@
 export { authorityOverride } from './writeAuthority.js';
-export { calculateNextTrigger, calculateNextTriggerFromNow, firstSlotForDay, isWithinActiveHours, matchesRecurrenceInterval, shouldTriggerOnDay, isStaleActive, isOccurrenceOverdue, STALE_ACTIVE_THRESHOLD_MS } from './scheduling.js';
+export { calculateNextTrigger, calculateNextTriggerFromNow, firstSlotForDay, isWithinActiveHours, matchesRecurrenceInterval, shouldTriggerOnDay, isStaleActive, isOccurrenceOverdue, todaySlotTime, STALE_ACTIVE_THRESHOLD_MS } from './scheduling.js';
 export { isTimeOfDayOutsideActiveHours } from './activeHours.js';
 export { coarsenIdleTime, IDLE_TIME_BUCKET_SECONDS } from './coarsenIdleTime.js';
 export { formatNextTrigger } from './formatNextTrigger.js';
+export { badgeFor, isEnded, isPastOnce } from './reminderBadges.js';
 export { buildSignedPayload } from './integrityPayload.js';
 export { versionSatisfies, isNewer } from './semver.js';
 export { shouldAutoClose } from './shouldAutoClose.js';

package/dist/reminderBadges.d.ts

@@ -0,0 +1,9 @@
+import type { ResponsibilityDef, ScheduledReminder } from './types.js';
+export type ReminderBadgeTone = 'active' | 'docked' | 'snoozed' | 'done';
+export interface ReminderBadge {
+    label: string;
+    tone: ReminderBadgeTone;
+}
+export declare function isEnded(def: ResponsibilityDef, now?: number): boolean;
+export declare function isPastOnce(def: ResponsibilityDef, now?: number): boolean;
+export declare function badgeFor(def: ResponsibilityDef, reminder: ScheduledReminder | undefined, dockedDefIds: ReadonlySet<string>, now?: number): ReminderBadge | null;

package/dist/reminderBadges.js

@@ -0,0 +1,24 @@
+import { formatNextTrigger } from './formatNextTrigger.js';
+export function isEnded(def, now = Date.now()) {
+    return def.endTime != null && now >= new Date(def.endTime).getTime();
+}
+export function isPastOnce(def, now = Date.now()) {
+    return def.recurrenceType === 'once' && new Date(def.startDateTime).getTime() < now;
+}
+export function badgeFor(def, reminder, dockedDefIds, now = Date.now()) {
+    if (isEnded(def, now))
+        return { label: 'Ended', tone: 'done' };
+    if (!reminder) {
+        return isPastOnce(def, now) ? { label: 'Done', tone: 'done' } : null;
+    }
+    if (reminder.status === 'active') {
+        return dockedDefIds.has(def.id) ? { label: 'Docked', tone: 'docked' } : { label: 'Active', tone: 'active' };
+    }
+    if (reminder.status === 'delayed') {
+        const until = formatNextTrigger(reminder.delayUntil && reminder.delayUntil > 0 ? reminder.delayUntil : reminder.nextTriggerTime, now);
+        return until === 'N/A' ? { label: 'Snoozed', tone: 'snoozed' } : { label: `Snoozed until ${until}`, tone: 'snoozed' };
+    }
+    if (reminder.status === 'completed')
+        return { label: 'Done', tone: 'done' };
+    return null;
+}

package/dist/scheduling.d.ts

@@ -1,6 +1,7 @@
 import { type ResponsibilityDef, type ScheduledReminder } from './types.js';
 export declare const STALE_ACTIVE_THRESHOLD_MS: number;
 export declare function shouldTriggerOnDay(def: ResponsibilityDef, date: Date): boolean;
+export declare function todaySlotTime(def: ResponsibilityDef, now: number): number;
 export declare function isWithinActiveHours(now: number, startTime: string, endTime: string): boolean;
 export declare function matchesRecurrenceInterval(def: ResponsibilityDef, day: Date, startDate: Date, anchorDayStartMs: number): boolean;
 export declare function calculateNextTrigger(def: ResponsibilityDef, fromTime: number, activeStart: string, activeEnd: string): number | null;

package/dist/scheduling.js

@@ -5,6 +5,18 @@ export function shouldTriggerOnDay(def, date) {
     const dayOfWeek = date.getDay();
     return def.daysOfWeek.includes(dayOfWeek);
 }
+// Today's occurrence slot for a def: the anchor's LOCAL wall-clock hour:minute
+// (from startDateTime) applied to `now`'s calendar day, seconds/ms zeroed.
+// Wall-clock-local by design (mirrors firstSlotForDay's non-hourly anchor):
+// absolute-ms math drifts +1h across DST transitions. Consumers: the engine's
+// missed-occurrence gates and the creation loop's due-ness check — a single
+// source so the gates can never drift from settle's due-ness.
+export function todaySlotTime(def, now) {
+    const startTime = new Date(def.startDateTime);
+    const todayScheduled = new Date(now);
+    todayScheduled.setHours(startTime.getHours(), startTime.getMinutes(), 0, 0);
+    return todayScheduled.getTime();
+}
 export function isWithinActiveHours(now, startTime, endTime) {
     const date = new Date(now);
     const [startH, startM] = startTime.split(':').map(Number);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@upnextapp/core",
-  "version": "0.19.0",
+  "version": "0.21.0",
   "type": "module",
   "description": "Platform-agnostic core for UpNext: domain types, scheduling math, integrity payloads",
   "license": "MIT",
@@ -15,7 +15,8 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": "./dist/index.js",
+      "require": "./dist/cjs/index.js"
     }
   },
   "sideEffects": false,
@@ -26,7 +27,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && tsc -p tsconfig.cjs.json && node -e \"require('fs').writeFileSync('dist/cjs/package.json', JSON.stringify({ type: 'commonjs' }, null, 2) + '\\n')\"",
     "prepublishOnly": "npm run build"
   },
   "peerDependencies": {