@upnextapp/core 0.17.0

package/README.md

@@ -0,0 +1,5 @@
+# @upnextapp/core
+
+Platform-agnostic core for UpNext: domain types, scheduling math, integrity payloads, semver utilities. Consumed by the desktop app (via source alias), the plugin SDK (dependency + re-export), and the future mobile client (via npm).
+
+Versioning: lockstep with the root app version — never bump independently. See `docs/superpowers/specs/2026-08-15-plugin-sdk-split-design.md`.

package/dist/activeHours.d.ts

@@ -0,0 +1 @@
+export declare function isTimeOfDayOutsideActiveHours(startDateTime: string, activeStart: string, activeEnd: string): boolean;

package/dist/activeHours.js

@@ -0,0 +1,28 @@
+export 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/coarsenIdleTime.d.ts

@@ -0,0 +1,2 @@
+export declare const IDLE_TIME_BUCKET_SECONDS = 15;
+export declare function coarsenIdleTime(seconds: number): number;

package/dist/coarsenIdleTime.js

@@ -0,0 +1,4 @@
+export const IDLE_TIME_BUCKET_SECONDS = 15;
+export function coarsenIdleTime(seconds) {
+    return Math.floor(seconds / IDLE_TIME_BUCKET_SECONDS) * IDLE_TIME_BUCKET_SECONDS;
+}

package/dist/formatNextTrigger.d.ts

@@ -0,0 +1 @@
+export declare function formatNextTrigger(ts: number | undefined, now?: number): string;

package/dist/formatNextTrigger.js

@@ -0,0 +1,11 @@
+export 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/index.d.ts

@@ -0,0 +1,10 @@
+export type { ReminderStatus, ScheduledReminder, RecurrenceType, ResponsibilityDef, AppSettings, StoreSchema } from './types';
+export { calculateNextTrigger, calculateNextTriggerFromNow, firstSlotForDay, isWithinActiveHours, matchesRecurrenceInterval, shouldTriggerOnDay, isStaleActive, isOccurrenceOverdue, STALE_ACTIVE_THRESHOLD_MS, HOURLY_STALE_THRESHOLD_MS } from './scheduling';
+export { isTimeOfDayOutsideActiveHours } from './activeHours';
+export { coarsenIdleTime, IDLE_TIME_BUCKET_SECONDS } from './coarsenIdleTime';
+export { formatNextTrigger } from './formatNextTrigger';
+export { buildSignedPayload } from './integrityPayload';
+export { versionSatisfies, isNewer } from './semver';
+export { shouldAutoClose } from './shouldAutoClose';
+export { validatePluginManifest, pluginManifestSchema } from './manifest';
+export type { PluginManifest } from './manifest';

package/dist/index.js

@@ -0,0 +1,8 @@
+export { calculateNextTrigger, calculateNextTriggerFromNow, firstSlotForDay, isWithinActiveHours, matchesRecurrenceInterval, shouldTriggerOnDay, isStaleActive, isOccurrenceOverdue, STALE_ACTIVE_THRESHOLD_MS, HOURLY_STALE_THRESHOLD_MS } from './scheduling';
+export { isTimeOfDayOutsideActiveHours } from './activeHours';
+export { coarsenIdleTime, IDLE_TIME_BUCKET_SECONDS } from './coarsenIdleTime';
+export { formatNextTrigger } from './formatNextTrigger';
+export { buildSignedPayload } from './integrityPayload';
+export { versionSatisfies, isNewer } from './semver';
+export { shouldAutoClose } from './shouldAutoClose';
+export { validatePluginManifest, pluginManifestSchema } from './manifest';

package/dist/integrityPayload.d.ts

@@ -0,0 +1 @@
+export declare function buildSignedPayload(pluginId: string, version: string, entryPath: string, entrySha256: string): string;

package/dist/integrityPayload.js

@@ -0,0 +1,6 @@
+// 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'
+export function buildSignedPayload(pluginId, version, entryPath, entrySha256) {
+    return `${pluginId}:${version}:${entryPath}:${entrySha256}`;
+}

package/dist/manifest.d.ts

@@ -0,0 +1,90 @@
+import { z } from 'zod';
+export declare const pluginManifestSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodString>;
+    icon: z.ZodOptional<z.ZodString>;
+    color: z.ZodOptional<z.ZodString>;
+    minPlatformVersion: z.ZodOptional<z.ZodString>;
+    capabilities: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    client: z.ZodObject<{
+        entry: z.ZodString;
+        pages: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            icon: z.ZodString;
+        }, z.core.$strip>>>;
+        windows: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            size: z.ZodObject<{
+                width: z.ZodNumber;
+                height: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"full">]>;
+            }, z.core.$strip>;
+            position: z.ZodOptional<z.ZodEnum<{
+                center: "center";
+                "right-edge": "right-edge";
+                "left-edge": "left-edge";
+            }>>;
+            frameless: z.ZodOptional<z.ZodBoolean>;
+            alwaysOnTop: z.ZodOptional<z.ZodBoolean>;
+            persistent: z.ZodOptional<z.ZodBoolean>;
+            skipTaskbar: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        reminderTypes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        settingsPanel: z.ZodOptional<z.ZodBoolean>;
+        componentMap: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>;
+    server: z.ZodOptional<z.ZodObject<{
+        entry: z.ZodString;
+        routes: z.ZodDefault<z.ZodArray<z.ZodAny>>;
+        webhooks: z.ZodDefault<z.ZodArray<z.ZodAny>>;
+        cronJobs: z.ZodDefault<z.ZodArray<z.ZodAny>>;
+        tables: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        env: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PluginManifest = z.infer<typeof pluginManifestSchema>;
+export declare function validatePluginManifest(data: unknown): z.ZodSafeParseResult<{
+    id: string;
+    name: string;
+    version: string;
+    capabilities: string[];
+    client: {
+        entry: string;
+        pages: {
+            id: string;
+            label: string;
+            icon: string;
+        }[];
+        windows: {
+            id: string;
+            size: {
+                width: number;
+                height: number | "full";
+            };
+            position?: "center" | "right-edge" | "left-edge" | undefined;
+            frameless?: boolean | undefined;
+            alwaysOnTop?: boolean | undefined;
+            persistent?: boolean | undefined;
+            skipTaskbar?: boolean | undefined;
+        }[];
+        reminderTypes: string[];
+        settingsPanel?: boolean | undefined;
+        componentMap?: Record<string, string> | undefined;
+    };
+    description?: string | undefined;
+    author?: string | undefined;
+    icon?: string | undefined;
+    color?: string | undefined;
+    minPlatformVersion?: string | undefined;
+    server?: {
+        entry: string;
+        routes: any[];
+        webhooks: any[];
+        cronJobs: any[];
+        tables: string[];
+        env: string[];
+    } | undefined;
+}>;

package/dist/manifest.js

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+const windowConfigSchema = z.object({
+    id: z.string().min(1),
+    size: z.object({
+        width: z.number().positive(),
+        height: z.union([z.number().positive(), z.literal('full')]),
+    }),
+    position: z.enum(['center', 'right-edge', 'left-edge']).optional(),
+    frameless: z.boolean().optional(),
+    alwaysOnTop: z.boolean().optional(),
+    persistent: z.boolean().optional(),
+    skipTaskbar: z.boolean().optional(),
+});
+const pageConfigSchema = z.object({
+    id: z.string().min(1),
+    label: z.string(),
+    icon: z.string(),
+});
+export const pluginManifestSchema = z.object({
+    id: 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: z.string().min(1),
+    version: z.string().regex(/^\d+\.\d+\.\d+$/),
+    description: z.string().optional(),
+    author: z.string().optional(),
+    icon: z.string().optional(),
+    color: z.string().optional(),
+    minPlatformVersion: z.string().optional(),
+    capabilities: z.array(z.string()).default([]),
+    client: z.object({
+        entry: z.string().min(1).refine(e => !e.includes('..') && !e.startsWith('/'), {
+            message: 'Entry path must not contain ".." or start with "/"',
+        }),
+        pages: z.array(pageConfigSchema).default([]),
+        windows: z.array(windowConfigSchema).default([]),
+        reminderTypes: z.array(z.string()).default([]),
+        settingsPanel: z.boolean().optional(),
+        componentMap: z.record(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'), z.string().min(1).refine(e => !e.includes('..') && !e.startsWith('/'), {
+            message: 'Path must not contain ".." or start with "/"',
+        })).optional(),
+    }),
+    server: z
+        .object({
+        entry: z.string().min(1).refine(e => !e.includes('..') && !e.startsWith('/'), {
+            message: 'Entry path must not contain ".." or start with "/"',
+        }),
+        routes: z.array(z.any()).default([]),
+        webhooks: z.array(z.any()).default([]),
+        cronJobs: z.array(z.any()).default([]),
+        tables: z.array(z.string()).default([]),
+        env: z.array(z.string()).default([]),
+    })
+        .optional(),
+});
+export function validatePluginManifest(data) {
+    return pluginManifestSchema.safeParse(data);
+}

package/dist/scheduling.d.ts

@@ -0,0 +1,11 @@
+import { type ResponsibilityDef, type ScheduledReminder } from './types';
+export declare const STALE_ACTIVE_THRESHOLD_MS: number;
+export declare const HOURLY_STALE_THRESHOLD_MS: number;
+export declare function shouldTriggerOnDay(def: ResponsibilityDef, date: Date): boolean;
+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;
+export declare function firstSlotForDay(def: ResponsibilityDef, day: Date, anchorInstant: number, activeStart: string, activeEnd: string, fromTime: number): number | null;
+export declare function calculateNextTriggerFromNow(def: ResponsibilityDef, fromTime: number, activeStart: string, activeEnd: string): number | null;
+export declare function isStaleActive(reminder: ScheduledReminder, now: number, def?: ResponsibilityDef): boolean;
+export declare function isOccurrenceOverdue(def: ResponsibilityDef, reminder: ScheduledReminder, now: number, activeStart: string, activeEnd: string): boolean;

package/dist/scheduling.js

@@ -0,0 +1,198 @@
+export const STALE_ACTIVE_THRESHOLD_MS = 48 * 60 * 60 * 1000;
+export const HOURLY_STALE_THRESHOLD_MS = 24 * 60 * 60 * 1000;
+export function shouldTriggerOnDay(def, date) {
+    if (!def.daysOfWeek || def.daysOfWeek.length === 0)
+        return true;
+    const dayOfWeek = date.getDay();
+    return def.daysOfWeek.includes(dayOfWeek);
+}
+export 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();
+}
+export 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;
+    }
+}
+export 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.
+export 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;
+}
+export function calculateNextTriggerFromNow(def, fromTime, activeStart, activeEnd) {
+    if (!def.enabled)
+        return null;
+    if (def.recurrenceType === 'once')
+        return null;
+    return calculateNextTrigger(def, fromTime, activeStart, activeEnd);
+}
+export function isStaleActive(reminder, now, def) {
+    if (!reminder.activatedAt)
+        return true;
+    const threshold = def?.recurrenceType === 'hourly' ? HOURLY_STALE_THRESHOLD_MS : STALE_ACTIVE_THRESHOLD_MS;
+    return (now - reminder.activatedAt) > threshold;
+}
+export 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/semver.d.ts

@@ -0,0 +1,2 @@
+export declare function versionSatisfies(appVersion: string, minVersion: string): boolean;
+export declare function isNewer(current: string, candidate: string): boolean;

package/dist/semver.js

@@ -0,0 +1,32 @@
+export 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;
+}
+export 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/shouldAutoClose.d.ts

@@ -0,0 +1 @@
+export declare function shouldAutoClose(expanded: boolean, dragHighlight: boolean, lastInteraction: number, now: number, thresholdMs?: number): boolean;

package/dist/shouldAutoClose.js

@@ -0,0 +1,3 @@
+export function shouldAutoClose(expanded, dragHighlight, lastInteraction, now, thresholdMs = 5000) {
+    return expanded && !dragHighlight && (now - lastInteraction) > thresholdMs;
+}

package/dist/types.d.ts

@@ -0,0 +1,36 @@
+export type ReminderStatus = 'scheduled' | 'active' | 'delayed' | 'completed';
+export interface ScheduledReminder {
+    defId: string;
+    status: ReminderStatus;
+    nextTriggerTime: number;
+    activatedAt?: number;
+    delayUntil?: number;
+    lastCompletedAt?: number;
+    pluginData?: Record<string, unknown>;
+}
+export type RecurrenceType = 'once' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly';
+export interface ResponsibilityDef {
+    id: string;
+    title: string;
+    recurrenceType: RecurrenceType;
+    interval?: number;
+    startDateTime: string;
+    endTime?: string;
+    enabled: boolean;
+    daysOfWeek?: number[];
+    pluginId?: string;
+    reminderType?: string;
+    pluginData?: Record<string, unknown>;
+}
+export interface AppSettings {
+    activeStartTime: string;
+    activeEndTime: string;
+    autostart: boolean;
+    drawerEdge: 'right' | 'left';
+}
+export interface StoreSchema {
+    version: number;
+    responsibilities: ResponsibilityDef[];
+    reminders: ScheduledReminder[];
+    settings: AppSettings;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@upnextapp/core",
+  "version": "0.17.0",
+  "type": "module",
+  "description": "Platform-agnostic core for UpNext: domain types, scheduling math, integrity payloads",
+  "license": "MIT",
+  "author": "UpNext",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/morcth/upnext",
+    "directory": "packages/core"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "peerDependencies": {
+    "zod": "^3.0.0 || ^4.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "zod": "^4.4.3"
+  }
+}