@atlastodo/shared 0.0.0-stage → 0.1.11-rc.7

package/dist/members.d.ts

@@ -0,0 +1,26 @@
+import type { MemberRole } from "@atlastodo/client-core";
+/**
+ * A shared-project member as stored locally. The server authors `project_member` entities into each
+ * member's sync partition, so the collaborator list and assignee picker read from the local store,
+ * offline included. The client never writes them; membership changes go through the REST endpoints.
+ */
+export interface Member {
+    id: string;
+    project_id: string;
+    user_id: string;
+    email: string;
+    display_name: string;
+    role: MemberRole;
+    state: "pending" | "active";
+    deletion_scheduled?: boolean;
+}
+export declare function toMember(id: string, fields: Record<string, unknown>): Member;
+/** Whether `projectId` is shared, has active owners, and all of them are scheduled for deletion. */
+export declare function isOwnerDeletionScheduled(members: Pick<Member, "project_id" | "role" | "state" | "deletion_scheduled">[], projectId: string): boolean;
+/**
+ * Whether `userId` may act as owner of `projectId`, the gate for destructive actions (mirrors the
+ * server's owner-only rule). A project with no member rows is private to its creator, who is the
+ * implicit owner. Once shared, only an active `role: "owner"` qualifies; others can only leave.
+ */
+export declare function isProjectOwner(members: Pick<Member, "project_id" | "user_id" | "role" | "state">[], projectId: string, userId: string | undefined): boolean;
+export declare function initialsOf(member: Pick<Member, "display_name" | "email">): string;

package/dist/planDay.d.ts

@@ -0,0 +1,31 @@
+import type { Task } from "@atlastodo/client-core";
+/**
+ * Helpers for the Today screen's plan-my-day review. The only persisted outcome is due-date
+ * changes (`planDayWrites` reduces decisions to plain `{ id, dueAt }` writes).
+ */
+export declare const PLAN_DAY_HORIZON_DAYS = 7;
+export type PlanDayBucket = "overdue" | "today" | "upcoming";
+export interface PlanDayItem {
+    task: Task;
+    bucket: PlanDayBucket;
+}
+export declare function planDayItems(tasks: Task[], now: number, timeZone?: string): PlanDayItem[];
+export declare function planDayUpcoming(tasks: Task[], now: number, timeZone?: string, days?: number): Task[];
+export interface PlanDayOption {
+    offset: number;
+    dueAt: number;
+}
+export declare function planDayPostponeOptions(now: number, timeZone?: string, days?: number): PlanDayOption[];
+export type PlanDayDecision = {
+    kind: "keep";
+} | {
+    kind: "postpone";
+    dueAt: number;
+} | {
+    kind: "later";
+};
+export interface PlanDayWrite {
+    id: string;
+    dueAt: number;
+}
+export declare function planDayWrites(items: PlanDayItem[], decisions: Record<string, PlanDayDecision | undefined>, todayEnd: number): PlanDayWrite[];

package/dist/pomodoro.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Pomodoro state machine: pure and time-free. The running clock lives in the FocusProvider; this
+ * decides which phase comes next and how long each lasts.
+ */
+export type Phase = "work" | "short_break" | "long_break";
+export interface PomodoroConfig {
+    workMin: number;
+    shortBreakMin: number;
+    longBreakMin: number;
+    longBreakEvery: number;
+}
+export declare const DEFAULT_POMODORO: PomodoroConfig;
+export type FocusCorner = "top-left" | "top-right" | "bottom-left" | "bottom-right";
+export declare const FOCUS_CORNERS: FocusCorner[];
+export declare const DEFAULT_FOCUS_CORNER: FocusCorner;
+export declare function isFocusCorner(value: unknown): value is FocusCorner;
+export declare function phaseDurationMs(phase: Phase, config: PomodoroConfig): number;
+export declare function formatClock(ms: number): string;
+export declare function nextPhase(phase: Phase, completedWork: number, config: PomodoroConfig): Phase;
+export interface PomodoroState {
+    phase: Phase;
+    completedWork: number;
+}
+export declare function advance(state: PomodoroState, config: PomodoroConfig): PomodoroState;
+export interface RunSnapshot {
+    taskId: string | null;
+    phase: Phase;
+    completedWork: number;
+    remainingMs: number;
+    running: boolean;
+    awaitingStart: boolean;
+    workStartedAt: number;
+    workElapsedMs: number;
+}
+export interface FocusSessionLog {
+    taskId: string | null;
+    startedAt: number;
+    endedAt: number;
+    durationMs: number;
+}
+/**
+ * Recompute a persisted run at a later `now`. A running one completes at most one phase: one that
+ * ended while the app was closed parks on the next phase with `awaitingStart`, rather than
+ * replaying a break nobody was present for.
+ */
+export declare function rehydrateRun(saved: RunSnapshot, savedAt: number, now: number, config: PomodoroConfig): {
+    run: RunSnapshot;
+    sessions: FocusSessionLog[];
+};

package/dist/priority.d.ts

@@ -0,0 +1,2 @@
+/** Priority -> accent color for the flag icon. P4 (default) has no entry (shows no flag). */
+export declare const PRIORITY_COLOR: Record<number, string>;

package/dist/projectMapper.d.ts

@@ -0,0 +1,15 @@
+import type { Project, ProjectKind, ProjectView } from "@atlastodo/client-core";
+export declare function toProject(id: string, fields: Record<string, unknown>): Project;
+/**
+ * The fields written when creating a project or folder. `parent_id` is always written, even null,
+ * so a later move is a plain update.
+ */
+export declare function projectCreateFields(input: {
+    name: string;
+    color?: string;
+    icon?: string;
+    sort_order?: number;
+    kind?: ProjectKind;
+    parent_id?: string | null;
+    default_view?: ProjectView;
+}): Record<string, unknown>;

package/dist/projectStyle.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Per-project icon and colour: the portable half. Each app maps names to its own icon components;
+ * keep both keyed by {@link PROJECT_ICON_NAMES}.
+ */
+export declare const DEFAULT_PROJECT_ICON = "hash";
+export declare const DEFAULT_FILTER_ICON = "filter";
+export declare const DEFAULT_FOLDER_ICON = "folder";
+export declare const PROJECT_ICON_NAMES: string[];
+export declare const PROJECT_COLORS: string[];
+export declare function defaultColorForIndex(n: number): string;
+export declare function resolveProjectColor(project: {
+    id: string;
+    color: string;
+}): string;

package/dist/projectTree.d.ts

@@ -0,0 +1,40 @@
+import type { Project } from "@atlastodo/client-core";
+/**
+ * The project forest: a flat `Project[]` as a nested render list. A folder is a project with
+ * `kind: "folder"` that holds no tasks and groups others via `parent_id`.
+ *
+ * Exports are named differently from `taskTree`'s because `index.ts` star-exports both (TS2308).
+ *
+ * Orphans are roots: a co-member of a shared project can receive a `parent_id` naming a folder
+ * never shared with them and would otherwise lose the project.
+ *
+ * Cycles are guarded here only (the server does not validate parents on the sync path), so
+ * {@link wouldCycleProject} is the enforcement and every walk carries a `seen` guard.
+ */
+export interface ProjectTreeNode {
+    project: Project;
+    depth: number;
+    children: ProjectTreeNode[];
+}
+export interface FlatProjectRow {
+    project: Project;
+    depth: number;
+    hasChildren: boolean;
+    childCount: number;
+}
+export declare function buildProjectTree(projects: Project[]): ProjectTreeNode[];
+export declare function flattenProjectTree(projects: Project[], collapsed?: ReadonlySet<string>): FlatProjectRow[];
+export declare function projectAncestors(projects: Project[], id: string): Project[];
+export declare function projectDescendantIds(projects: Project[], id: string): Set<string>;
+export declare function wouldCycleProject(projects: Project[], movingId: string, candidateParentId: string | null): boolean;
+export declare function moveProjectTarget(projects: Project[], id: string, newParentId: string | null): {
+    parent_id: string | null;
+    sort_order: number;
+} | null;
+export declare function hiddenProjectIds(items: ReadonlyArray<{
+    id: string;
+    parent_id: string | null;
+    archived_at: number | null;
+    deleted_at: number | null;
+}>): Set<string>;
+export declare function pinnedProjectTree(projects: Project[], isPinned: (projectId: string) => boolean, collapsed?: ReadonlySet<string>): FlatProjectRow[];

package/dist/quickAddLexicons.d.ts

@@ -0,0 +1,64 @@
+import type { Freq } from "./recurrence.js";
+/**
+ * Quick-add vocabulary, one lexicon per UI language. `quickAddParse` matches the UI language's
+ * lexicon first and English after it, so English phrases work in every language. Every phrase is
+ * lowercase and space-separated, and is matched accent-insensitively ({@link fold}), so "manana",
+ * "lunedi" and "uebermorgen" work as well as the proper spelling.
+ */
+export interface QuickAddLexicon {
+    /** Month before day ("jun 3") as well as day before month ("3 jun"). */
+    monthFirst?: boolean;
+    /** Words for a count of one: "in a week", "om en uge". */
+    one: string[];
+    /** A unit straight after an `inPrefixes` word means one of it: Polish "za tydzień". */
+    inBareUnit?: boolean;
+    /** Time prefixes that may be glued to the hour: Danish "kl17", "kl.9:30". */
+    gluedTimePrefixes?: string[];
+    /** Phrases that name a day relative to today: "morgen" → 1. */
+    relativeDays: Record<string, number>;
+    /** Weekday names and their inflected/plural forms, Sunday = 0. */
+    weekdays: Record<string, number>;
+    /** Month names (and the genitive forms dates use), January = 0. */
+    months: Record<string, number>;
+    /** Day/week/month/year in every form a count can take. */
+    units: Record<string, Freq>;
+    /** Before a count and unit: "in 3 Tagen" → "in". */
+    inPrefixes: string[];
+    /** Before a weekday or unit: "nächsten Montag". */
+    nextPrefixes: string[];
+    /** After a weekday or unit: "lundi prochain". */
+    nextSuffixes: string[];
+    /** Before a weekday: "diesen Freitag". */
+    thisPrefixes: string[];
+    /**
+     * Words consumed in front of a date only when the date follows: "am Montag", "el lunes",
+     * "w środę", "la semaine prochaine". Never matched on their own.
+     */
+    leadIns: string[];
+    /** Between a day number and its month: "3 de marzo". */
+    monthConnectors: string[];
+    /** Before a weekday, a unit, or a count and unit: "jede Woche", "alle 2 Wochen". */
+    every: string[];
+    /** One word or phrase that is a whole rule: "täglich" → daily. */
+    single: Record<string, Freq>;
+    /** After a rule: schedule from the completion date, like `every!`. */
+    fromCompletion: string[];
+    /**
+     * Before a time. `true` accepts a bare hour ("um 17"); `false` needs minutes ("o 17:30"), for a
+     * prefix that is also an everyday word.
+     */
+    timePrefixes: Record<string, boolean>;
+    /** A word after the hour: "17 Uhr". */
+    timeSuffixes: string[];
+    /** Letter glued to the hour: "17h30" (French), "17u" (Dutch). */
+    hourLetter?: string;
+    noon: string[];
+    midnight: string[];
+}
+/** Lowercase, strip accents and unify apostrophes, for accent-insensitive matching. */
+export declare function fold(s: string): string;
+/**
+ * The (folded) lexicons to match for a UI language such as "de" or "pt-BR", in order: its own, then
+ * English. English alone for English, no language, or one without a lexicon.
+ */
+export declare function quickAddLexicons(language: string | undefined): QuickAddLexicon[];

package/dist/quickAddLexiconsWire.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The quick-add lexicons as plain JSON, for the Rust client (`crates/atlas-client`), which reads
+ * them from `crates/atlas-client/src/rules/quick_add_lexicons.json`. Phrase maps become lists of
+ * `[phrase, value]` pairs so their order (which breaks ties between equally long matches) survives.
+ * `quickAddLexiconsWire.test.ts` fails when that file is stale; regenerate it with
+ * `bun packages/shared/scripts/export-quick-add-lexicons.ts`.
+ */
+export declare const QUICK_ADD_LANGUAGES: readonly ["en", "da", "de", "es", "fr", "it", "nl", "pl", "pt"];
+type Wire = Record<string, unknown>;
+export declare function quickAddLexiconsWire(): Record<string, Wire>;
+export {};

package/dist/quickAddParse.d.ts

@@ -0,0 +1,44 @@
+import type { CreateTaskInput } from "@atlastodo/client-core";
+import { DEFAULT_DUE_HOUR, DEFAULT_DUE_MINUTE } from "./zonedTime.js";
+/**
+ * Natural-language quick-add parsing ("Buy milk tomorrow 5pm #groceries p1") into a
+ * {@link CreateTaskInput} plus preview chips. `every!` or a trailing `from completion` schedules
+ * from the completion date. Never throws: unrecognized input stays in the title.
+ */
+export { DEFAULT_DUE_HOUR, DEFAULT_DUE_MINUTE };
+export type ChipKind = "due" | "project" | "label" | "priority" | "recurrence";
+export interface ParsedChip {
+    kind: ChipKind;
+    label: string;
+}
+export interface TokenSpan {
+    start: number;
+    end: number;
+    text: string;
+    value: string;
+}
+export interface QuickAddContext {
+    projectIdByName?: (name: string) => string | null;
+    isKnownLabel?: (name: string) => boolean;
+    timeZone?: string;
+    language?: string;
+    ignoreDates?: string[];
+    ignoreProjects?: string[];
+    ignoreLabels?: string[];
+    disableDates?: boolean;
+}
+export interface DateMatchSpan {
+    start: number;
+    end: number;
+    text: string;
+}
+export interface QuickAddResult {
+    input: CreateTaskInput;
+    title: string;
+    chips: ParsedChip[];
+    dateMatch?: DateMatchSpan;
+    projectMatch?: TokenSpan;
+    labelMatches?: TokenSpan[];
+    labels: string[];
+}
+export declare function parseQuickAdd(text: string, now: number, ctx?: QuickAddContext): QuickAddResult;

package/dist/quickSchedule.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Quick reschedule targets for the swipe-left day picker and compose bar: `now` injected, optional
+ * IANA `timeZone`. Each lands on 23:59 of its day, so the task is all-day.
+ */
+export interface QuickScheduleOption {
+    key: "today" | "tomorrow" | "weekend" | "nextWeek";
+    dueAt: number;
+}
+export declare function quickScheduleOptions(now: number, timeZone?: string): QuickScheduleOption[];

package/dist/rank.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Fractional ranking for `sort_order`. Ordering uses a `f64` `sort_order` so an item can be re-ranked between two neighbours
+ * without renumbering the whole list: the new rank is the midpoint of its neighbours' ranks.
+ *
+ * `before`/`after` are the `sort_order` values of the items that will sit immediately before and
+ * after the moved item at its destination; pass `null` when there is no such neighbour (the moved
+ * item lands at the start/end, or the list is empty).
+ */
+export declare function rankBetween(before: number | null, after: number | null): number;

package/dist/recurrence.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Task recurrence (asserted against `test-vectors/recurrence_vectors.json`).
+ *
+ * A compact RRULE subset, e.g. `FREQ=WEEKLY;INTERVAL=2;BYDAY=MO,WE`, plus non-standard
+ * `MODE=COMPLETION` (next occurrence based on the completion time).
+ *
+ * A monthly rule keeps its day in `BYMONTHDAY` ({@link anchorMonthDay}): stepping from the previous
+ * occurrence would turn "the 31st" into "the 28th" for good after one February. A yearly rule due
+ * on a leap day keeps it the same way (`BYMONTHDAY=29`, the only day a yearly rule takes), so it
+ * returns to Feb 29 in leap years.
+ *
+ * The engine ({@link nextOccurrenceCivil}) steps wall-clock dates and keeps the time of day, so
+ * "every day at 23:59" does not drift across DST. Month and leap-day overflows clamp.
+ */
+export type Freq = "daily" | "weekly" | "monthly" | "yearly";
+export type RecurMode = "on_schedule" | "after_completion";
+export interface Rule {
+    freq: Freq;
+    interval: number;
+    byday: number[];
+    bymonthday: number | null;
+    mode: RecurMode;
+    at?: {
+        hour: number;
+        minute: number;
+    } | null;
+}
+export declare const MAX_INTERVAL = 1000;
+export declare function parseRule(input: string): Rule | null;
+export declare function ruleToString(rule: Rule): string;
+export declare function anchorMonthDay(rule: string, dueMs: number, timeZone?: string): string;
+export declare function pinMonthDay(rule: string, dueMs: number, timeZone?: string): string;
+export type Translate = (key: string, params: Record<string, string | number>) => string;
+export declare function formatRule(input: string, t?: Translate): string | null;
+export interface CivilDateTime {
+    year: number;
+    month: number;
+    day: number;
+    hour: number;
+    minute: number;
+    second: number;
+    millisecond: number;
+}
+export interface CivilDate {
+    year: number;
+    month: number;
+    day: number;
+}
+export declare function nextOccurrenceCivil(rule: string, anchor: CivilDateTime, from: CivilDate): CivilDateTime | null;
+/**
+ * The occurrence after `dueMs` and the rule to store with it (also given the leap-day and month-day
+ * anchors of {@link pinMonthDay}). When the next occurrence falls in a DST gap it shows a later
+ * time than the series' own, so the rule keeps the series' time (`BYHOUR`/`BYMINUTE`) to step from;
+ * the first occurrence that shows it again drops it. `null` when there is no next occurrence.
+ */
+export declare function advanceSeries(rule: string, dueMs: number, fromMs: number, timeZone?: string): {
+    next: number;
+    rule: string;
+} | null;
+export declare function nextOccurrence(rule: string, anchorMs: number, fromMs: number, timeZone?: string): number | null;

package/dist/regions.d.ts

@@ -0,0 +1,6 @@
+export declare const REGION_OPTIONS: {
+    tag: string;
+    label: string;
+}[];
+export declare const COMMON_TIME_ZONES: string[];
+export declare function timeZoneOptions(): string[];

package/dist/reminderSchedule.d.ts

@@ -0,0 +1,42 @@
+import type { Task } from "@atlastodo/client-core";
+import { type Reminder } from "./reminders.js";
+/**
+ * OS-scheduled reminder planning: decides which local notifications to book and diffs that against
+ * what is booked, so reconciling is idempotent. Keys off {@link reminderFireAt}, so it is
+ * DST-correct. Platform differences live in the injected {@link ScheduleIO}.
+ */
+export interface ScheduledReminder {
+    reminderId: string;
+    fireAt: number;
+    title: string;
+    body?: string;
+}
+export interface ScheduleDiff {
+    toSchedule: ScheduledReminder[];
+    toCancel: string[];
+}
+export interface ScheduleIO {
+    schedule: (title: string, body: string, at: number, id: string) => void;
+    cancel: (id: string) => void;
+}
+export interface ReminderTitleOptions {
+    lockedTitle?: string;
+    fallbackTitle?: string;
+}
+export interface ReminderPlanOptions extends ReminderTitleOptions {
+    timeZone?: string;
+}
+export declare function reminderTitle(task: Task | undefined, options?: ReminderTitleOptions): string;
+export declare function reminderBody(task: Task | undefined): string;
+export declare function futureReminders(reminders: Reminder[], tasks: Task[], now: number, options?: ReminderPlanOptions): ScheduledReminder[];
+export interface ApplyOptions {
+    rebook?: boolean;
+}
+export declare function diffSchedule(desired: ScheduledReminder[], scheduled: Map<string, number>, { rebook }?: ApplyOptions): ScheduleDiff;
+export declare function applySchedule(desired: ScheduledReminder[], scheduled: Map<string, number>, body: string, io: ScheduleIO, options?: ApplyOptions): void;
+export declare function adoptBooked(booked: readonly string[], desired: ScheduledReminder[], scheduled: Map<string, number>): void;
+export declare function reconcileSchedule(reminders: Reminder[], tasks: Task[], now: number, scheduled: Map<string, number>): ScheduleDiff;
+export interface ReconcileOptions extends ReminderPlanOptions, ApplyOptions {
+    booked?: readonly string[];
+}
+export declare function reconcileNotifications(reminders: Reminder[], tasks: Task[], now: number, scheduled: Map<string, number>, body: string, io: ScheduleIO, options?: ReconcileOptions): void;

package/dist/reminders.d.ts

@@ -0,0 +1,28 @@
+import type { Task } from "@atlastodo/client-core";
+/**
+ * Task reminders: pure scheduling logic. A reminder fires at an absolute time (`at`) or
+ * `offset_min_before_due` minutes before the due date. `fired_at` is synced and covers the fire
+ * instant it went out for, so a later-moved instant makes it unfired again ({@link isReminderFired}).
+ *
+ * All-day dues are 23:59 in the task's calendar, so day-based offsets resolve in `timeZone`, not
+ * the device-local reading, which disagrees once the device zone differs.
+ */
+export interface Reminder {
+    id: string;
+    task_id: string;
+    at: number | null;
+    offset_min_before_due: number | null;
+    fired_at: number | null;
+    created_at: number;
+}
+export declare function toReminder(id: string, fields: Record<string, unknown>): Reminder;
+export declare function reminderFireAt(reminder: Reminder, task: Task | undefined, timeZone?: string): number | null;
+export declare const MORNING_OF_OFFSET_MIN = 0;
+export declare function morningReminderOffset(dueAt: number | null | undefined, now: number, timeZone?: string): number | null;
+export declare function isReminderFired(reminder: Reminder, fireAt: number): boolean;
+export declare function dueReminders(reminders: Reminder[], tasks: Task[], now: number, timeZone?: string): Reminder[];
+export declare const REMINDER_STALE_AFTER_MS: number;
+export declare function splitDueReminders(reminders: Reminder[], tasks: Task[], now: number, timeZone?: string, staleAfterMs?: number): {
+    fire: Reminder[];
+    stale: Reminder[];
+};

package/dist/reorder.d.ts

@@ -0,0 +1,21 @@
+export interface RankWrite {
+    id: string;
+    sort_order: number;
+}
+/**
+ * The writes that place `movedId` at `toIndex` among `siblings`. Tasks without a rank all default
+ * to `0` and `rankBetween` returns the tie value between them, so a move would snap back: a single
+ * fractional write is kept only when strictly between the neighbours, else siblings are renumbered.
+ */
+export declare function rankMoveWrites(siblings: readonly {
+    id: string;
+    sort_order: number;
+}[], movedId: string, toIndex: number): RankWrite[];
+export declare function reorderRank<T extends {
+    id: string;
+    sort_order: number;
+}>(items: T[], from: number, to: number): {
+    id: string;
+    sort_order: number;
+    writes: RankWrite[];
+} | null;

package/dist/sectionMapper.d.ts

@@ -0,0 +1,8 @@
+import type { Section } from "@atlastodo/client-core";
+export declare function toSection(id: string, fields: Record<string, unknown>): Section;
+/** The fields to write when creating a section locally. */
+export declare function sectionCreateFields(input: {
+    project_id: string;
+    name: string;
+    sort_order?: number;
+}): Record<string, unknown>;

package/dist/sectionOps.d.ts

@@ -0,0 +1,5 @@
+import type { LocalStore, Section, Task } from "@atlastodo/client-core";
+export declare function allSections(store: LocalStore): Section[];
+export declare function visibleSections(store: LocalStore, projectId: string): Section[];
+export declare function moveSectionToProject(store: LocalStore, sectionId: string, targetProjectId: string, now?: number, tasks?: Task[]): void;
+export declare function setSectionArchived(store: LocalStore, sectionId: string, archived: boolean, now?: number): void;

package/dist/serverUrl.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Server-URL resolution: pure, so both frontends share the rule. Reading and writing the override
+ * is the platform's job. Atlas Todo is self-hosted, so a stored override beats the build-time
+ * default.
+ */
+/**
+ * The effective server URL. A blank override means "not set" (clearing the settings field) and
+ * falls back to `fallback`. The trailing slash is removed because callers build
+ * `${baseUrl}${path}`.
+ */
+export declare function resolveServerUrl(override: string | null | undefined, fallback: string): string;
+export declare function stripTrailingSlash(url: string): string;

package/dist/smartLists.d.ts

@@ -0,0 +1,11 @@
+import type { Task } from "@atlastodo/client-core";
+export declare function isOverdue(task: Task, now: number, _timeZone?: string): boolean;
+export declare function inboxTasks(tasks: Task[]): Task[];
+export declare function todayTasks(tasks: Task[], now: number, timeZone?: string): Task[];
+export declare function partitionToday(tasks: Task[], now: number, timeZone?: string): {
+    overdue: Task[];
+    today: Task[];
+};
+export declare function assignedToMe(tasks: Task[], userId: string): Task[];
+export declare function openTasks(tasks: Task[]): Task[];
+export declare function upcomingTasks(tasks: Task[], now: number, timeZone?: string): Task[];

package/dist/stats.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Productivity aggregates over completed tasks: pure, ranges passed in. Days are keyed by calendar
+ * date in `timeZone` and iteration walks whole date keys (DST-safe), reusing the habit date
+ * helpers.
+ */
+import type { Task } from "@atlastodo/client-core";
+export interface DayCount {
+    date: string;
+    count: number;
+}
+export interface WeekCount {
+    weekStart: string;
+    count: number;
+}
+export interface ProjectCount {
+    projectId: string | null;
+    count: number;
+}
+export declare function completionsByDay(tasks: Task[], fromMs: number, toMs: number, timeZone?: string): DayCount[];
+export declare function completionsByWeek(tasks: Task[], fromMs: number, toMs: number, weekStartsOn?: number, timeZone?: string): WeekCount[];
+export declare function completionsByProject(tasks: Task[], fromMs: number, toMs: number): ProjectCount[];
+export declare function totalCompleted(tasks: Task[], fromMs: number, toMs: number): number;
+/**
+ * "Karma" streak: consecutive days ending today with a completed task. Today gets grace (no
+ * completions yet does not break it); an earlier empty day does.
+ */
+export declare function completedStreak(tasks: Task[], todayMs: number, timeZone?: string): number;
+export declare function completedHistory(tasks: Task[], query: string): Task[];

package/dist/swipe.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Horizontal swipe gestures on task rows. {@link classifySwipe} counts a drag only when it travels
+ * far enough and is clearly more horizontal than vertical, so it never hijacks a scroll.
+ * {@link resolveTaskSwipe} decides what the configured action means for one row.
+ */
+export interface Point {
+    x: number;
+    y: number;
+}
+export type SwipeDirection = "right" | "left" | "none";
+export type TaskSwipeAction = "complete" | "schedule" | "indent" | "delete" | "none";
+export declare const TASK_SWIPE_ACTIONS: TaskSwipeAction[];
+export declare function isTaskSwipeAction(v: unknown): v is TaskSwipeAction;
+export interface SwipeConfig {
+    threshold: number;
+    axisRatio: number;
+}
+export declare const DEFAULT_SWIPE: SwipeConfig;
+export declare function classifySwipe(start: Point, end: Point, config?: SwipeConfig): SwipeDirection;
+export type TaskSwipeEffect = "complete" | "schedule" | "indent" | "outdent" | "delete";
+export interface TaskSwipeRow {
+    locked: boolean;
+    isSubtask: boolean;
+    canIndent: boolean;
+    canOutdent: boolean;
+}
+export declare function resolveTaskSwipe(action: TaskSwipeAction, row: TaskSwipeRow): TaskSwipeEffect | null;
+export declare function isHorizontal(start: Point, end: Point, config?: SwipeConfig): boolean;
+export declare function clampOffset(dx: number, max: number): number;

package/dist/taskClipboard.d.ts

@@ -0,0 +1,19 @@
+import type { Task } from "@atlastodo/client-core";
+export interface ClipboardContext {
+    originOf?: (task: Task) => {
+        project?: string;
+        section?: string;
+    } | undefined;
+    formatDue?: (ms: number) => string;
+    formatStart?: (ms: number) => string;
+    formatRecurrence?: (rule: string) => string;
+    labelsOf?: (task: Task) => string[];
+    assigneeOf?: (task: Task) => string | undefined;
+}
+/**
+ * Serialize selected tasks to a readable clipboard block: one `- {title} (metadata)` line per task,
+ * description indented beneath. Metadata carries all user data (due, start, priority p1..p3,
+ * recurrence, estimate, labels, assignee, project/section); id-based fields appear only when the
+ * caller supplies a resolver. The single serialization source of truth.
+ */
+export declare function serializeTasksForClipboard(tasks: Task[], ctx?: ClipboardContext): string;

package/dist/taskListTree.d.ts

@@ -0,0 +1,33 @@
+import type { Task } from "@atlastodo/client-core";
+import { type GroupBy, type GroupContext } from "./grouping.js";
+import { type FlatTaskRow } from "./taskTree.js";
+/**
+ * A task list's rendered shape: where {@link ./grouping} and {@link ./taskTree} are composed.
+ *
+ * Views filter tasks individually, so a matching task's parent or open subtasks are often outside
+ * the set. A group is widened before nesting with the open subtasks below its matched tasks and
+ * the parents needed to reach them; a pulled-in parent is context (`matched: false`).
+ *
+ * Grouping runs on the matched set alone, so no bucket vanishes and no matched task changes
+ * bucket. Both walks stop at a matched task, so a parent and child in different buckets cannot
+ * nest; the child renders at depth 0. Order is injected because `buildTaskTree` re-orders every
+ * level: roots take the group's order, siblings take `sortBy`.
+ */
+export interface ListTaskRow extends FlatTaskRow {
+    matched: boolean;
+}
+export interface TaskListSection {
+    key: string;
+    kind: GroupBy;
+    accent?: "danger";
+    matched: Task[];
+    tasks: Task[];
+    rows: ListTaskRow[];
+}
+export interface TaskListTreeOptions extends GroupContext {
+    groupBy: GroupBy;
+    allTasks?: Task[];
+    collapsedTasks?: ReadonlySet<string>;
+}
+export declare function taskContextClosure(sectionTasks: Task[], allTasks: Task[], matchedIds: ReadonlySet<string>): Task[];
+export declare function taskListSections(matched: Task[], options: TaskListTreeOptions): TaskListSection[];