things-api 0.7.0 → 0.9.0

package/dist/read/views.js

@@ -1,8 +1,13 @@
 import { addDaysIso, encodePackedDate, localToday } from "../model/dates.js";
+import { logBoundary, markLogged } from "./log-boundary.js";
 import { mapProject, mapTodo } from "../model/mappers.js";
 import { projectOccurrences } from "../model/occurrences.js";
 import { decodeRecurrenceRule } from "../model/recurrence.js";
-import { fetchTagsForTasks, fetchTaskRows, makeRefResolver, NOT_TEMPLATE, resolveAreaUuid, resolveProjectUuid, resolveTagUuid, tagScopeBinds, tagScopeSql, tagWithDescendants, } from "./queries.js";
+import { fetchTagsForTasks, fetchTaskRows, makeHeadingProjectResolver, makeRefResolver, NOT_TEMPLATE, resolveAreaUuid, resolveProjectUuid, resolveTagUuid, tagScopeBinds, tagScopeSql, tagWithDescendants, } from "./queries.js";
+import { ANYTIME_SELF, CONTAINER_UNTRASHED, EFF_PROJECT, LIVE, OPEN, PROJECT_ANYTIME_ACTIVE, } from "./predicates.js";
+import { groupBySidebar } from "./sidebar-order.js";
+import { areasView } from "./tags.js";
+import { compareSearchMatches } from "./search-rank.js";
 function tagFilter(db, filter) {
     if (filter?.tag === undefined)
         return { sql: "", binds: [] };
@@ -10,14 +15,22 @@ function tagFilter(db, filter) {
     const uuids = filter.exactTag === true ? [target] : tagWithDescendants(db, target);
     return { sql: ` AND ${tagScopeSql(uuids.length)}`, binds: tagScopeBinds(uuids) };
 }
-const LIVE = `t.type IN (0, 1) AND t.trashed = 0 AND ${NOT_TEMPLATE}`;
-const OPEN = `${LIVE} AND t.status = 0`;
 function materialize(db, rows) {
     const refs = makeRefResolver(db);
+    const headingProject = makeHeadingProjectResolver(db);
     const tags = fetchTagsForTasks(db, rows.map((r) => r.uuid));
-    return rows.map((row) => row.type === 1
-        ? mapProject(row, refs, tags.get(row.uuid) ?? [])
-        : mapTodo(row, refs, tags.get(row.uuid) ?? []));
+    const items = rows.map((row) => {
+        if (row.type === 1)
+            return mapProject(row, refs, tags.get(row.uuid) ?? []);
+        const todo = mapTodo(row, refs, tags.get(row.uuid) ?? []);
+        if (todo.heading !== null) {
+            const p = headingProject(todo.heading.uuid);
+            if (p !== null)
+                todo.headingProject = p;
+        }
+        return todo;
+    });
+    return markLogged(items, logBoundary(db));
 }
 export function todayView(db, now, filter) {
     const todayIso = localToday(now);
@@ -34,7 +47,7 @@ export function todayView(db, now, filter) {
     //    (the date the item ENTERED Today: its startDate, or its deadline for
     //    deadline-driven members), then todayIndex ASC, then uuid (observed
     //    stable tiebreak).
-    const rows = fetchTaskRows(db, `${OPEN} AND (
+    const rows = fetchTaskRows(db, `${OPEN} AND ${CONTAINER_UNTRASHED} AND (
        (t.startDate IS NOT NULL AND t.startDate <= ? AND t.start IN (1, 2))
        OR (t.deadline IS NOT NULL AND t.deadline <= ? AND t.startDate IS NULL
            AND (t.deadlineSuppressionDate IS NULL OR t.deadlineSuppressionDate < t.deadline))
@@ -58,24 +71,6 @@ export function inboxView(db, filter) {
     const rows = fetchTaskRows(db, `${OPEN} AND t.start = 0${tf.sql} ORDER BY t."index" ASC`, tf.binds);
     return materialize(db, rows);
 }
-/** An item's own anytime membership: unscheduled-active, or dated <= today. */
-const ANYTIME_SELF = (col) => `((${col}.start = 1 AND (${col}.startDate IS NULL OR ${col}.startDate <= ?))
-    OR (${col}.start = 2 AND ${col}.startDate IS NOT NULL AND ${col}.startDate <= ?))`;
-/**
- * The item's effective project: its own link, or its heading's project for
- * headed children (heading rows carry the project link).
- */
-const EFF_PROJECT = `COALESCE(t.project, (SELECT h.project FROM TMTask h WHERE h.uuid = t.heading))`;
-/**
- * Container cascade (live-verified against the UI, 2026-07-09): a to-do
- * inside a project that is NOT itself anytime-visible (someday or
- * future-scheduled, logged, or trashed) is absent from Anytime regardless of
- * the to-do's own start state — the project row alone represents it.
- * Projects and container-less to-dos pass through. Two binds (packedToday ×2).
- */
-const PROJECT_ANYTIME_ACTIVE = `(${EFF_PROJECT} IS NULL OR EXISTS (
-     SELECT 1 FROM TMTask p WHERE p.uuid = ${EFF_PROJECT}
-     AND p.trashed = 0 AND p.status = 0 AND ${ANYTIME_SELF("p")}))`;
 export function anytimeView(db, now, filter) {
     const packedToday = encodePackedDate(localToday(now));
     const tf = tagFilter(db, filter);
@@ -86,106 +81,22 @@ export function anytimeView(db, now, filter) {
      AND ${PROJECT_ANYTIME_ACTIVE}${tf.sql} ORDER BY t."index" ASC`, [packedToday, packedToday, packedToday, packedToday, ...tf.binds]);
     return groupBySidebar(db, materialize(db, rows));
 }
-/**
- * Arranges view members into the UI's flat sidebar-mirroring order: the
- * area-less block first (direct to-dos, then each top-level project followed
- * by its members), then each area by its sidebar index (direct to-dos, then
- * its projects). Project and area order here mirrors the sidebar exactly —
- * both read the same "index" columns.
- */
-function groupBySidebar(db, items) {
-    if (items.length === 0)
-        return [];
-    const inList = (n) => Array.from({ length: n }, () => "?").join(", ");
-    // Headed children: resolve heading -> project.
-    const headingUuids = [
-        ...new Set(items.flatMap((i) => (i.type === "to-do" && i.heading !== null ? [i.heading.uuid] : []))),
-    ];
-    const headingProject = new Map();
-    if (headingUuids.length > 0) {
-        for (const row of db
-            .prepare(`SELECT uuid, project FROM TMTask WHERE uuid IN (${inList(headingUuids.length)})`)
-            .all(...headingUuids)) {
-            headingProject.set(row.uuid, row.project);
-        }
-    }
-    const effProject = (i) => i.type !== "to-do"
-        ? null
-        : (i.project?.uuid ??
-            (i.heading !== null ? (headingProject.get(i.heading.uuid) ?? null) : null));
-    // Sidebar rank + title for areas; index + area for every referenced project
-    // (a tag-filtered list can contain a child whose project row didn't match).
-    const areaRows = db
-        .prepare(`SELECT uuid, title, "index" FROM TMArea ORDER BY "index" ASC, uuid ASC`)
-        .all();
-    const areaRank = new Map(areaRows.map((a, rank) => [a.uuid, rank]));
-    const areaTitle = new Map(areaRows.map((a) => [a.uuid, a.title ?? ""]));
-    const projectUuids = [
-        ...new Set([
-            ...items.flatMap((i) => (i.type === "project" ? [i.uuid] : [])),
-            ...items.flatMap((i) => {
-                const p = effProject(i);
-                return p === null ? [] : [p];
-            }),
-        ]),
-    ];
-    const projectMeta = new Map();
-    if (projectUuids.length > 0) {
-        for (const row of db
-            .prepare(`SELECT uuid, "index", area FROM TMTask WHERE uuid IN (${inList(projectUuids.length)})`)
-            .all(...projectUuids)) {
-            projectMeta.set(row.uuid, { index: row.index ?? 0, area: row.area });
-        }
-    }
-    // items arrive in SQL "index" order, so array position IS the per-container
-    // rank (the internal index is no longer exposed on the entity).
-    const sortKey = (i, pos) => {
-        const project = i.type === "project" ? i.uuid : effProject(i);
-        const meta = project === null ? undefined : projectMeta.get(project);
-        const area = i.area?.uuid ?? meta?.area ?? null;
-        return {
-            areaRank: area === null ? -1 : (areaRank.get(area) ?? areaRows.length),
-            area: area ?? "",
-            inProject: project === null ? 0 : 1,
-            projectIndex: meta?.index ?? 0,
-            project: project ?? "",
-            headerFirst: i.type === "project" ? 0 : 1,
-            pos,
-            uuid: i.uuid,
-        };
-    };
-    const keyed = items.map((item, pos) => ({ item, k: sortKey(item, pos) }));
-    keyed.sort((a, b) => a.k.areaRank - b.k.areaRank ||
-        a.k.area.localeCompare(b.k.area) ||
-        a.k.inProject - b.k.inProject ||
-        a.k.projectIndex - b.k.projectIndex ||
-        a.k.project.localeCompare(b.k.project) ||
-        a.k.headerFirst - b.k.headerFirst ||
-        a.k.pos - b.k.pos ||
-        a.k.uuid.localeCompare(b.k.uuid));
-    const sections = [];
-    for (const { item, k } of keyed) {
-        const areaUuid = k.area === "" ? null : k.area;
-        const last = sections.at(-1);
-        if (last === undefined || (last.area?.uuid ?? null) !== areaUuid) {
-            sections.push({
-                area: areaUuid === null ? null : { uuid: areaUuid, title: areaTitle.get(areaUuid) ?? "" },
-                items: [],
-            });
-        }
-        sections.at(-1)?.items.push(item);
-    }
-    return sections;
-}
 /** The UI's star marker in Anytime: the item is also a Today member. */
 export function isTodayMember(item, now) {
     return item.startDate !== null && item.startDate <= localToday(now);
 }
 export function upcomingView(db, now, filter) {
     const packedToday = encodePackedDate(localToday(now));
+    const until = filter?.until;
+    const since = filter?.since;
+    const untilSql = until === undefined ? "" : " AND t.startDate <= ?";
+    const untilBinds = until === undefined ? [] : [encodePackedDate(until)];
+    const sinceSql = since === undefined ? "" : " AND t.startDate >= ?";
+    const sinceBinds = since === undefined ? [] : [encodePackedDate(since)];
     const tf = tagFilter(db, filter);
-    const rows = fetchTaskRows(db, `${OPEN} AND t.start = 2 AND t.startDate IS NOT NULL AND t.startDate > ?${tf.sql}
-     ORDER BY t.startDate ASC, t."index" ASC`, [packedToday, ...tf.binds]);
+    const rows = fetchTaskRows(db, `${OPEN} AND ${CONTAINER_UNTRASHED}
+     AND t.start = 2 AND t.startDate IS NOT NULL AND t.startDate > ?${untilSql}${sinceSql}${tf.sql}
+     ORDER BY t.startDate ASC, t."index" ASC`, [packedToday, ...untilBinds, ...sinceBinds, ...tf.binds]);
     const items = materialize(db, rows);
     if (filter?.repeats === false)
         return items;
@@ -194,19 +105,22 @@ export function upcomingView(db, now, filter) {
     // completion templates carry no next date until the prior instance
     // resolves; paused templates are excluded. The occurrence deadline follows
     // the instance-validated model: deadline = startDate − rule.startOffsetDays.
-    const templateRows = fetchTaskRows(db, `t.type IN (0, 1) AND t.trashed = 0 AND t.status = 0
+    const templateRows = fetchTaskRows(db, `t.type IN (0, 1) AND t.trashed = 0 AND t.status = 0 AND ${CONTAINER_UNTRASHED}
      AND (t.rt1_recurrenceRule IS NOT NULL OR t.repeater IS NOT NULL)
      AND t.rt1_instanceCreationPaused = 0
-     AND t.rt1_nextInstanceStartDate IS NOT NULL AND t.rt1_nextInstanceStartDate > ?${tf.sql}
-     ORDER BY t.rt1_nextInstanceStartDate ASC, t."index" ASC`, [packedToday, ...tf.binds]);
+     AND t.rt1_nextInstanceStartDate IS NOT NULL AND t.rt1_nextInstanceStartDate > ?${until === undefined ? "" : " AND t.rt1_nextInstanceStartDate <= ?"}${since === undefined ? "" : " AND t.rt1_nextInstanceStartDate >= ?"}${tf.sql}
+     ORDER BY t.rt1_nextInstanceStartDate ASC, t."index" ASC`, [packedToday, ...untilBinds, ...sinceBinds, ...tf.binds]);
     const horizon = Math.max(1, Math.min(10, Math.trunc(filter?.horizon ?? 1)));
     const rawByUuid = new Map(templateRows.map((r) => [r.uuid, r.rt1_recurrenceRule]));
     const occurrences = materialize(db, templateRows).flatMap((template) => {
         const startDate = template.repeating.nextOccurrence ?? null;
         if (startDate === null)
             return [];
-        // Only the rule-derived deadline is real: the template row's own deadline
-        // column carries app-internal sentinels (4001-01-01 observed live).
+        // Whether occurrences deadline is the TEMPLATE's property, not the rule's:
+        // a deadline-less template (repeating.deadlined false) spawns instances
+        // with NO deadline even for fixed ts=0 rules — its rt1_recurrenceRule is
+        // byte-identical to a deadlined ts=0 rule (oddities §8a, UI1 2026-07-12).
+        const deadlined = template.repeating.deadlined === true;
         let rule = null;
         const raw = rawByUuid.get(template.uuid);
         if (raw !== null && raw !== undefined) {
@@ -218,25 +132,60 @@ export function upcomingView(db, now, filter) {
             }
         }
         if (rule === null || horizon === 1 || rule.type !== "fixed") {
-            const deadline = rule !== null && rule.startOffsetDays < 0
-                ? addDaysIso(startDate, -rule.startOffsetDays)
-                : null;
+            // Deadlined templates deadline the occurrence at the event date
+            // (start − ts, incl. ts=0); deadline-less ones carry no deadline.
+            const deadline = rule !== null && deadlined ? addDaysIso(startDate, -rule.startOffsetDays) : null;
             return [{ ...template, startDate, deadline }];
         }
         // horizon > 1: later occurrences PROJECTED from the decoded rule,
-        // anchored on the app's own materialized next instance.
-        return projectOccurrences(rule, startDate, { count: horizon }).map((o) => ({
+        // anchored on the app's own materialized next instance. The until bound
+        // clips projections the same way it clips stored rows.
+        return (projectOccurrences(rule, startDate, {
+            count: horizon,
+            ...(until !== undefined && { until }),
+        }, deadlined)
+            .filter((o) => until === undefined || o.startDate <= until)
+            .filter((o) => since === undefined || o.startDate >= since)
+            // oxlint-disable-next-line no-map-spread -- building fresh occurrence objects, not mutating
+            .map((o) => ({
             ...template,
             startDate: o.startDate,
             deadline: o.deadline,
-        }));
+        })));
     });
-    return [...items, ...occurrences]
+    // Within a day the UI's drag order is todayIndex ASC (live-verified
+    // 2026-07-11 against the GUI: plain `index` disagrees, todayIndex matches
+    // exactly), so the sortable Upcoming order survives the CLI.
+    const todayIndexOf = new Map([...rows, ...templateRows].map((r) => [r.uuid, r.todayIndex ?? 0]));
+    const dated = [...items, ...occurrences]
         .map((item, pos) => ({ item, pos }))
         .toSorted((a, b) => (a.item.startDate ?? "").localeCompare(b.item.startDate ?? "") ||
+        (todayIndexOf.get(a.item.uuid) ?? 0) - (todayIndexOf.get(b.item.uuid) ?? 0) ||
         a.pos - b.pos ||
         a.item.uuid.localeCompare(b.item.uuid))
         .map((x) => x.item);
+    // The UI's trailing "Repeating To-Dos" section: templates with NO set
+    // next occurrence (after-completion rules between instances, rules past
+    // their end date) plus paused ones — startDate stays null, the decoded
+    // rule rides along so consumers can derive waiting/paused/ended.
+    const restingRows = fetchTaskRows(db, `t.type IN (0, 1) AND t.trashed = 0 AND t.status = 0 AND ${CONTAINER_UNTRASHED}
+     AND (t.rt1_recurrenceRule IS NOT NULL OR t.repeater IS NOT NULL)
+     AND (t.rt1_nextInstanceStartDate IS NULL OR t.rt1_nextInstanceStartDate <= ?
+          OR t.rt1_instanceCreationPaused = 1)${tf.sql}
+     ORDER BY t.todayIndex ASC, t."index" ASC`, [packedToday, ...tf.binds]);
+    const resting = materialize(db, restingRows).map((item) => {
+        const raw = restingRows.find((r) => r.uuid === item.uuid)?.rt1_recurrenceRule;
+        if (raw !== null && raw !== undefined) {
+            try {
+                item.repeating.rule = decodeRecurrenceRule(raw);
+            }
+            catch {
+                // undecodable rule (future Things build) — surface without it
+            }
+        }
+        return item;
+    });
+    return [...dated, ...resting];
 }
 export function somedayView(db, now, filter) {
     const tf = tagFilter(db, filter);
@@ -251,29 +200,130 @@ export function somedayView(db, now, filter) {
         : "0";
     const rows = fetchTaskRows(db, `${OPEN} AND t.start = 2 AND t.startDate IS NULL
      AND (${EFF_PROJECT} IS NULL OR ${childArm})${tf.sql} ORDER BY t."index" ASC`, [...(withActiveChildren ? [packedToday, packedToday] : []), ...tf.binds]);
-    return groupBySidebar(db, materialize(db, rows));
+    const sections = groupBySidebar(db, materialize(db, rows));
+    // GUI order within a Someday group (live side-by-side, 2026-07-12):
+    // PROJECT rows first (their sidebar order preserved), then direct to-dos in
+    // drag order. Someday children of active projects (the activeProjectItems
+    // toggle) trail the group, still clustered by their project — surfaces
+    // present them as a separate "From active projects" section.
+    const isChild = (i) => i.type === "to-do" && (i.project !== null || i.headingProject !== null);
+    return sections.map((s) => ({
+        area: s.area,
+        items: [
+            ...s.items.filter((i) => i.type === "project"),
+            ...s.items.filter((i) => i.type === "to-do" && !isChild(i)),
+            ...s.items.filter(isChild),
+        ],
+    }));
 }
 export function logbookView(db, options) {
-    const limit = options?.limit ?? 100;
+    const cap = options?.limit === null ? null : (options?.limit ?? 100);
     const tf = tagFilter(db, options);
-    const rows = fetchTaskRows(db, `${LIVE} AND t.status IN (2, 3)${tf.sql} ORDER BY t.stopDate DESC LIMIT ?`, [...tf.binds, limit]);
+    const where = [];
+    const binds = [];
+    if (options?.project !== undefined) {
+        where.push(`${EFF_PROJECT} = ?`);
+        binds.push(resolveProjectUuid(db, options.project));
+    }
+    if (options?.area !== undefined) {
+        const areaUuid = resolveAreaUuid(db, options.area);
+        where.push(`(t.area = ? OR EXISTS (SELECT 1 FROM TMTask p WHERE p.uuid = ${EFF_PROJECT} AND p.area = ?))`);
+        binds.push(areaUuid, areaUuid);
+    }
+    if (options?.since !== undefined) {
+        where.push("t.stopDate >= ?");
+        binds.push(options.since.getTime() / 1000);
+    }
+    if (options?.until !== undefined) {
+        where.push("t.stopDate <= ?");
+        binds.push(options.until.getTime() / 1000);
+    }
+    const extra = where.length > 0 ? ` AND ${where.join(" AND ")}` : "";
+    // Completion ≠ logged: closed items past the log-move boundary still sit
+    // checked in their original lists, exactly like the GUI's Logbook.
+    const rows = fetchTaskRows(db, `${LIVE} AND t.status IN (2, 3) AND t.stopDate <= ?${extra}${tf.sql} ORDER BY t.stopDate DESC${cap === null ? "" : " LIMIT ?"}`, [logBoundary(db).getTime() / 1000, ...binds, ...tf.binds, ...(cap === null ? [] : [cap])]);
     return materialize(db, rows);
 }
 export function trashView(db, options) {
-    const limit = options?.limit ?? 200;
+    const cap = options?.limit === null ? null : (options?.limit ?? 200);
     const rows = fetchTaskRows(db, `t.type IN (0, 1) AND t.trashed = 1 AND ${NOT_TEMPLATE}
-     ORDER BY t.userModificationDate DESC LIMIT ?`, [limit]);
+     ORDER BY t.userModificationDate DESC${cap === null ? "" : " LIMIT ?"}`, cap === null ? [] : [cap]);
     return materialize(db, rows);
 }
 export function projectsView(db, options) {
     // areaUuid accepts a uuid OR a unique (case-insensitive) title; ambiguous
     // or unknown references throw like every other ref resolver.
     const area = options?.areaUuid === undefined ? null : resolveAreaUuid(db, options.areaUuid);
+    const packedToday = encodePackedDate(localToday(options?.now));
+    // Sidebar default: LATER (someday + future-scheduled) projects are hidden —
+    // active means ANYTIME_SELF (a scheduled project whose date has arrived
+    // counts active, exactly the Anytime membership test). With later=true they
+    // append AFTER the active block of their group, never intermingled.
+    const laterSql = options?.later === true ? "" : ` AND ${ANYTIME_SELF("t")}`;
+    const laterBinds = options?.later === true ? [] : [packedToday, packedToday];
+    // "Active first" within each group needs the same test as an ORDER key
+    // (two more binds when later projects are included).
+    const activeFirst = options?.later === true ? `(CASE WHEN ${ANYTIME_SELF("t")} THEN 0 ELSE 1 END) ASC, ` : "";
+    const activeFirstBinds = options?.later === true ? [packedToday, packedToday] : [];
+    // Sidebar order, not raw global index (which interleaves areas): loose
+    // (area-less) projects first in their own drag order — the GUI lists them
+    // above the areas — then each area by ITS sidebar rank (TMArea."index"),
+    // projects within an area by their drag order.
     const where = area
-        ? `${OPEN} AND t.type = 1 AND t.area = ? ORDER BY t."index" ASC`
-        : `${OPEN} AND t.type = 1 ORDER BY t."index" ASC`;
-    const rows = fetchTaskRows(db, where, area ? [area] : []);
-    return materialize(db, rows);
+        ? `${OPEN} AND t.type = 1 AND t.area = ?${laterSql}
+       ORDER BY ${activeFirst}t."index" ASC`
+        : `${OPEN} AND t.type = 1${laterSql} ORDER BY (t.area IS NOT NULL) ASC,
+       (SELECT a."index" FROM TMArea a WHERE a.uuid = t.area) ASC, ${activeFirst}t."index" ASC`;
+    const rows = fetchTaskRows(db, where, [
+        ...(area ? [area] : []),
+        ...laterBinds,
+        ...activeFirstBinds,
+    ]);
+    const items = materialize(db, rows);
+    if (options?.later !== true)
+        return items;
+    // Each group's later sub-block reads like Upcoming: SCHEDULED projects
+    // first — date ascending, todayIndex within a day (the UI's drag order,
+    // hidden on entities but present on the raw rows) — then someday in drag
+    // order. The SQL already made group runs contiguous with actives leading,
+    // so only the later runs are re-sorted (stable within someday).
+    const todayIso = localToday(options?.now);
+    const ti = new Map(rows.map((r) => [r.uuid, r.todayIndex ?? 0]));
+    const isLater = (p) => p.startDate !== null ? p.startDate > todayIso : p.start === "someday";
+    const out = [];
+    let run = [];
+    let runArea;
+    const flush = () => {
+        out.push(...run
+            .map((item, pos) => ({ item, pos }))
+            .toSorted((a, b) => {
+            const ad = a.item.startDate;
+            const bd = b.item.startDate;
+            if (ad !== null && bd !== null)
+                return (ad.localeCompare(bd) ||
+                    (ti.get(a.item.uuid) ?? 0) - (ti.get(b.item.uuid) ?? 0) ||
+                    a.pos - b.pos);
+            if (ad !== null)
+                return -1;
+            if (bd !== null)
+                return 1;
+            return a.pos - b.pos; // someday keeps drag order
+        })
+            .map((x) => x.item));
+        run = [];
+    };
+    for (const item of items) {
+        const key = item.area?.uuid ?? null;
+        if (!isLater(item) || key !== runArea)
+            flush();
+        runArea = key;
+        if (isLater(item))
+            run.push(item);
+        else
+            out.push(item);
+    }
+    flush();
+    return out;
 }
 /**
  * Everything that changed since a moment — created or modified TMTask rows,
@@ -284,47 +334,132 @@ export function projectsView(db, options) {
  * parent task — those changes are invisible here.
  */
 export function changesView(db, options) {
-    const limit = options.limit ?? 200;
+    const cap = options.limit === null ? null : (options.limit ?? 200);
     const sinceEpoch = options.since.getTime() / 1000;
     const rows = fetchTaskRows(db, `t.type IN (0, 1) AND t.userModificationDate > ?
-     ORDER BY t.userModificationDate DESC LIMIT ?`, [sinceEpoch, limit]);
+     ORDER BY t.userModificationDate DESC${cap === null ? "" : " LIMIT ?"}`, [sinceEpoch, ...(cap === null ? [] : [cap])]);
+    // oxlint-disable-next-line no-map-spread -- building fresh change objects, not mutating
     return materialize(db, rows).map((item, i) => ({
         ...item,
         changeKind: (rows[i]?.creationDate ?? 0) > sinceEpoch ? "created" : "modified",
     }));
 }
+/**
+ * The did-you-mean fallback search: a case-insensitive SUBSTRING match on
+ * TITLES ONLY (never notes, headings, or checklist items), across areas,
+ * projects, and to-dos — open + untrashed only. Ordered per the house
+ * doctrine: containers (areas, then projects) first, then to-dos; within a
+ * group active rows precede someday rows, then most-recently-modified. `type`
+ * scopes to a single class (the typed-namespace paths). Results are capped
+ * (default 10); `total` reports the pre-cap match count so the caller can
+ * append a "… n more" tail.
+ */
+const somedayRank = (i) => (i.start === "someday" ? 1 : 0);
+/** Lite-search order within a task group: active before someday, then most-recently-modified. */
+function byStatusThenRecent(a, b) {
+    return somedayRank(a) - somedayRank(b) || b.modified.getTime() - a.modified.getTime();
+}
+export function liteTitleSearch(db, query, options) {
+    const cap = options?.limit ?? 10;
+    const type = options?.type;
+    const needle = query.toLowerCase();
+    const areas = type === undefined || type === "area"
+        ? areasView(db)
+            .filter((a) => a.title.toLowerCase().includes(needle))
+            .toSorted((a, b) => a.title.localeCompare(b.title))
+        : [];
+    let tasks = [];
+    if (type === undefined || type === "to-do" || type === "project") {
+        const typeSql = type === "to-do" ? "t.type = 0" : type === "project" ? "t.type = 1" : "t.type IN (0, 1)";
+        const rows = fetchTaskRows(db, `${OPEN} AND ${CONTAINER_UNTRASHED} AND ${typeSql} AND t.title LIKE ?`, [`%${query}%`]);
+        tasks = materialize(db, rows);
+    }
+    const projects = tasks.filter((t) => t.type === "project").toSorted(byStatusThenRecent);
+    const todos = tasks.filter((t) => t.type === "to-do").toSorted(byStatusThenRecent);
+    const ordered = [
+        ...areas.map((area) => ({ kind: "area", area })),
+        ...projects.map((task) => ({ kind: "task", task })),
+        ...todos.map((task) => ({ kind: "task", task })),
+    ];
+    return { candidates: ordered.slice(0, cap), total: ordered.length };
+}
 export function searchView(db, query, options) {
-    const limit = options?.limit ?? 50;
+    const cap = options?.limit === null ? null : (options?.limit ?? 50);
     const needle = `%${query}%`;
-    const where = [`${NOT_TEMPLATE} AND (t.title LIKE ? OR t.notes LIKE ?)`];
-    const binds = [needle, needle];
-    where.push(options?.type === "to-do"
+    // The scope predicates (everything except the match needle), reused verbatim
+    // for the needle query AND the heading-credited-project query so both honor
+    // the same type/status/scope constraints.
+    const scope = [NOT_TEMPLATE];
+    const scopeBinds = [];
+    scope.push(options?.type === "to-do"
         ? "t.type = 0"
         : options?.type === "project"
             ? "t.type = 1"
             : "t.type IN (0, 1)");
     // Scope: open + untrashed by default; --logged/--trashed widen; --all is
-    // the legacy include-everything behavior.
+    // the legacy include-everything behavior. Untrashed means the whole
+    // container chain (derived trash, A24B), not just the row's own flag.
     if (options?.all !== true) {
         const statuses = options?.logged === true ? "(0, 2, 3)" : "(0)";
-        where.push(`t.status IN ${statuses}`);
+        scope.push(`t.status IN ${statuses}`);
         if (options?.trashed !== true)
-            where.push("t.trashed = 0");
+            scope.push(`t.trashed = 0 AND ${CONTAINER_UNTRASHED}`);
     }
     if (options?.project !== undefined) {
         const uuid = resolveProjectUuid(db, options.project);
         // Children incl. headed ones (heading rows carry the project link).
-        where.push("(t.project = ? OR t.heading IN (SELECT uuid FROM TMTask WHERE type = 2 AND project = ?))");
-        binds.push(uuid, uuid);
+        scope.push("(t.project = ? OR t.heading IN (SELECT uuid FROM TMTask WHERE type = 2 AND project = ?))");
+        scopeBinds.push(uuid, uuid);
     }
     if (options?.area !== undefined) {
         const uuid = resolveAreaUuid(db, options.area);
-        where.push("t.area = ?");
-        binds.push(uuid);
+        scope.push("t.area = ?");
+        scopeBinds.push(uuid);
     }
     const tf = tagFilter(db, options);
-    const rows = fetchTaskRows(db, `${where.join(" AND ")}${tf.sql}
-     ORDER BY t.userModificationDate DESC LIMIT ?`, [...binds, ...tf.binds, limit]);
-    return materialize(db, rows);
+    // Needle matches: title OR notes. No SQL LIMIT — ranking runs before the cap.
+    const rows = fetchTaskRows(db, `${scope.join(" AND ")} AND (t.title LIKE ? OR t.notes LIKE ?)${tf.sql}`, [...scopeBinds, needle, needle, ...tf.binds]);
+    const needleLower = query.toLowerCase();
+    const matches = new Map();
+    for (const item of materialize(db, rows)) {
+        // Field credit: title beats notes when both carry the substring.
+        const field = item.title.toLowerCase().includes(needleLower) ? "title" : "notes";
+        matches.set(item.uuid, { item, field });
+    }
+    // Heading titles are treated as if they lived in the parent PROJECT's notes:
+    // a heading-title match surfaces the parent project (never a bare heading
+    // row), credited at the heading-via-project field rank. A to-do-only search
+    // has no project rows, so headings do not apply there.
+    if (options?.type !== "to-do") {
+        const headingRows = db
+            .prepare(`SELECT project AS projectUuid, title FROM TMTask
+         WHERE type = 2 AND project IS NOT NULL AND trashed = 0 AND title LIKE ?`)
+            .all(needle);
+        const headingTitleFor = new Map();
+        for (const h of headingRows) {
+            if (!headingTitleFor.has(h.projectUuid))
+                headingTitleFor.set(h.projectUuid, h.title ?? "");
+        }
+        // Surface only the projects NOT already matched by their own title/notes
+        // (a higher-ranked field already represents them), and only those passing
+        // the view's scope.
+        const wanted = [...headingTitleFor.keys()].filter((uuid) => !matches.has(uuid));
+        if (wanted.length > 0) {
+            const placeholders = wanted.map(() => "?").join(", ");
+            const projectRows = fetchTaskRows(db, `${scope.join(" AND ")} AND t.type = 1 AND t.uuid IN (${placeholders})${tf.sql}`, [...scopeBinds, ...wanted, ...tf.binds]);
+            for (const item of materialize(db, projectRows)) {
+                const matchedVia = {
+                    kind: "heading",
+                    title: headingTitleFor.get(item.uuid) ?? "",
+                };
+                // Annotate the freshly materialized entity in place (owned here).
+                item.matchedVia = matchedVia;
+                matches.set(item.uuid, { item, field: "heading", matchedVia });
+            }
+        }
+    }
+    const ranked = [...matches.values()].toSorted(compareSearchMatches);
+    const sliced = cap === null ? ranked : ranked.slice(0, cap);
+    return sliced.map((m) => m.item);
 }
 //# sourceMappingURL=views.js.map