@astrosheep/keiyaku 4.5.11 → 4.5.13

package/build/src/task/operations.js

@@ -1,16 +1,17 @@
 import { documentDiff } from "../markdown/diff.js";
-import { createTaskRelations, projectDetailFacts, projectTaskBoardObservation, relationProblem, projectBlocked, projectRows, } from "./board.js";
+import { createTaskRelations, projectOwnedDetailFacts, projectTaskBoardObservation, relationProblem, projectBlocked, projectRows, } from "./board.js";
 import { parseTaskCreationDocument, serializeTaskDocument, } from "./document.js";
 import { allocateLocalId, deriveLocalStem, formatTaskId, parseTaskId, sameNamespace } from "./identity.js";
-import { authorityPath, nukeTaskAuthority, readBoard, replaceAuthority, withTaskLocks } from "./store.js";
-import { DEFAULT_TASK_LIMIT, projectPage, projectQuery, queryUnderTargets, underExpression, } from "./query.js";
+import { nukeTaskAuthority, readBoard, readTaskDocument, replaceAuthority, withTaskLocks } from "./store.js";
+import { projectBoundedList } from "../bounded-list.js";
+import { taskRowViewLimit } from "./input.js";
+import { projectQuery, projectQueryRows, queryUnderTargets, underExpression, } from "./query.js";
+import { advanceTaskTimestamp, taskView } from "./view.js";
+export { advanceTaskTimestamp, taskView } from "./view.js";
 export async function nukeTask(world, options) {
     if ((await nukeTaskAuthority(world, options)) === "busy")
         throw new Error("Task reset lock contention");
 }
-export function taskView(document) {
-    return { ...document, namespace: parseTaskId(document.id).namespace };
-}
 function refused(refusal) {
     return { kind: "refused", refusal };
 }
@@ -27,9 +28,6 @@ function currentTimestamp() {
     return new Date().toISOString();
 }
 /** Internal Task timestamp rule shared by ordinary mutations and compose. */
-export function advanceTaskTimestamp(previous, candidate) {
-    return candidate > previous ? candidate : new Date(Date.parse(previous) + 1).toISOString();
-}
 function addDocument(base, namespace, board, at, actor) {
     const localId = allocateLocalId(deriveLocalStem(base.title), occupied(board, namespace));
     return {
@@ -46,20 +44,30 @@ function boardWith(board, document) {
     return { tasks };
 }
 async function create(world, base, namespace, signal, actor) {
-    const result = await withTaskLocks({ world, allocation: true, ids: [], ...(signal === undefined ? {} : { signal }) }, async () => {
-        const snapshot = await readBoard(world), next = addDocument(base, namespace, snapshot.board, currentTimestamp(), actor);
-        const problem = relationProblem(boardWith(snapshot.board, next), null, next);
-        if (problem !== null)
-            return refused({ kind: "invalid-graph", diagnostic: problem });
-        const replaced = await replaceAuthority({
-            path: authorityPath(world, next.id),
-            expected: null,
-            next: serializeTaskDocument(next),
+    let result;
+    try {
+        result = await withTaskLocks({ world, allocation: true, ids: [], ...(signal === undefined ? {} : { signal }) }, async () => {
+            const snapshot = await readBoard(world), next = addDocument(base, namespace, snapshot.board, currentTimestamp(), actor);
+            const problem = relationProblem(boardWith(snapshot.board, next), null, next);
+            if (problem !== null)
+                return refused({ kind: "invalid-graph", diagnostic: problem });
+            const replaced = await replaceAuthority({
+                world,
+                id: next.id,
+                expected: null,
+                next: serializeTaskDocument(next),
+            });
+            return replaced === "replaced"
+                ? { kind: "accepted", value: taskView(next) }
+                : retry("concurrent-modification");
         });
-        return replaced === "replaced"
-            ? { kind: "accepted", value: taskView(next) }
-            : retry("concurrent-modification");
-    });
+    }
+    catch (error) {
+        if (error instanceof TypeError &&
+            /task identity (?:cannot fit the physical filename budget|contains a Windows-reserved physical segment)/u.test(error.message))
+            return refused({ kind: "invalid-namespace-context", path: namespace.join("/") });
+        throw error;
+    }
     return result === "busy" ? retry("busy") : result;
 }
 export async function addTask(world, input) {
@@ -137,8 +145,7 @@ export async function updateTask(world, id, input) {
         const afterBytes = serializeTaskDocument(next);
         const after = Buffer.from(afterBytes).toString("utf8");
         if (before !== after &&
-            (await replaceAuthority({ path: authorityPath(world, id), expected: predecessor, next: afterBytes })) !==
-                "replaced") {
+            (await replaceAuthority({ world, id, expected: predecessor, next: afterBytes })) !== "replaced") {
             return { kind: "retry", reason: "concurrent-modification" };
         }
         const label = `${id}.md`;
@@ -149,98 +156,48 @@ export async function updateTask(world, id, input) {
     });
     return result === "busy" ? { kind: "retry", reason: "busy" } : result;
 }
-const TRANSITIONS = {
-    start: { open: "in_progress" },
-    stop: { in_progress: "open" },
-    hold: { open: "on_hold", in_progress: "on_hold" },
-    resume: { on_hold: "open" },
-    done: { open: "done", in_progress: "done", on_hold: "done" },
-    drop: { open: "drop", in_progress: "drop", on_hold: "drop" },
-};
-export async function lifecycleTask(world, id, verb, signal, note) {
-    const result = await withTaskLocks({ world, allocation: false, ids: [id], ...(signal === undefined ? {} : { signal }) }, async () => {
-        const snapshot = await readBoard(world), current = snapshot.board.tasks.get(id);
-        if (current === undefined)
-            return refused({ kind: "task-missing", taskId: id });
-        const state = TRANSITIONS[verb][current.state];
-        if (state === undefined) {
-            return refused({ kind: "invalid-lifecycle-transition", taskId: id, state: current.state, verb });
-        }
-        const at = currentTimestamp();
-        const next = {
-            ...current,
-            state,
-            ...(note === undefined ? {} : { note }),
-            updatedAt: advanceTaskTimestamp(current.updatedAt, at),
-        };
-        const bytes = serializeTaskDocument(next);
-        return (await replaceAuthority({
-            path: authorityPath(world, id),
-            expected: snapshot.bytes.get(id),
-            next: bytes,
-        })) === "replaced"
-            ? { kind: "accepted", value: taskView(next) }
-            : retry("concurrent-modification");
-    });
-    return result === "busy" ? retry("busy") : result;
-}
-export async function batchTasks(world, verb, ids, signal, note) {
-    const items = [];
-    for (const id of ids) {
-        signal?.throwIfAborted();
-        items.push({ id, outcome: await lifecycleTask(world, id, verb, signal, note) });
-    }
-    return { items };
-}
-export async function settleTask(world, id) {
-    const result = await withTaskLocks({ world, allocation: false, ids: [id] }, async () => {
-        const snapshot = await readBoard(world), current = snapshot.board.tasks.get(id);
-        if (current === undefined)
-            return { kind: "refused", refusal: { kind: "task-missing", taskId: id } };
-        if (current.state === "done")
-            return { kind: "unchanged" };
-        if (current.state === "drop") {
-            return {
-                kind: "refused",
-                refusal: { kind: "invalid-lifecycle-transition", taskId: id, state: current.state, verb: "done" },
-            };
-        }
-        const at = currentTimestamp();
-        const next = {
-            ...current,
-            state: "done",
-            updatedAt: advanceTaskTimestamp(current.updatedAt, at),
-        };
-        const replaced = await replaceAuthority({
-            path: authorityPath(world, id),
-            expected: snapshot.bytes.get(id),
-            next: serializeTaskDocument(next),
-        });
-        return replaced === "replaced"
-            ? { kind: "changed", task: taskView(next), action: "done" }
-            : { kind: "retry", reason: "concurrent-modification" };
-    });
-    return result === "busy" ? { kind: "retry", reason: "busy" } : result;
-}
+export { batchTasks, lifecycleTask, settleTask } from "./lifecycle-operations.js";
 function readScope(namespace, scope) {
     return scope === "world" ? null : (namespace ?? []);
 }
-export async function listTasks(world, namespace, selection, scope, limit = DEFAULT_TASK_LIMIT) {
+export async function listTasks(world, namespace, selection, scope, limit) {
+    const selectedLimit = taskRowViewLimit(limit);
     const selected = readScope(namespace, scope);
     const board = (await readBoard(world)).board;
     return {
         kind: "accepted",
-        value: projectPage(projectRows(board, createTaskRelations(board), selected, selection), limit),
+        value: projectBoundedList(projectRows(board, createTaskRelations(board), selected, selection), selectedLimit),
     };
 }
+export async function readTaskDetail(world, id) {
+    const task = await readTaskDocument(world, id);
+    if (task === undefined)
+        return null;
+    const selected = new Map([[id, task]]);
+    const references = [
+        ...task.needs,
+        ...(task.parent === null ? [] : [task.parent]),
+        ...task.supersedes,
+        ...task.relates,
+    ];
+    for (const reference of references) {
+        if (selected.has(reference))
+            continue;
+        const document = await readTaskDocument(world, reference);
+        if (document !== undefined)
+            selected.set(reference, document);
+    }
+    return projectOwnedDetailFacts({ tasks: selected }, id);
+}
 export async function readTaskDetails(world, ids) {
-    const board = (await readBoard(world)).board;
-    const relations = createTaskRelations(board);
-    const details = ids.map((id) => projectDetailFacts(board, id, relations));
-    const missing = details.findIndex((detail) => detail === null);
-    return missing < 0
-        ? { kind: "accepted", value: details }
-        : { kind: "refused", refusal: { kind: "task-missing", taskId: ids[missing] } };
+    const details = [];
+    for (const id of ids) {
+        const detail = await readTaskDetail(world, id);
+        if (detail === null)
+            return { kind: "refused", refusal: { kind: "task-missing", taskId: id } };
+        details.push(detail);
+    }
+    return { kind: "accepted", value: details };
 }
 export async function observeTaskDetails(world, ids) {
     const observed = await readTaskDetails(world, ids);
@@ -248,7 +205,8 @@ export async function observeTaskDetails(world, ids) {
         return observed;
     return { kind: "accepted", value: observed.value.map((facts) => ({ ...facts, task: taskView(facts.task) })) };
 }
-export async function readyTasks(world, namespace, scope, parent, limit = DEFAULT_TASK_LIMIT) {
+export async function readyTasks(world, namespace, scope, parent, limit) {
+    const selectedLimit = taskRowViewLimit(limit);
     const selected = readScope(namespace, scope);
     const board = (await readBoard(world)).board;
     if (parent !== undefined && !board.tasks.has(parent))
@@ -256,15 +214,15 @@ export async function readyTasks(world, namespace, scope, parent, limit = DEFAUL
     const relations = createTaskRelations(board);
     const ready = { kind: "predicate", predicate: { field: "ready", operator: "=", value: true } };
     const expression = parent === undefined ? ready : { kind: "and", terms: [ready, underExpression(parent)] };
-    const selectedRows = projectQuery(board, relations, {
+    const selectedRows = projectQueryRows(board, relations, {
         scope: selected,
         expression,
-        limit: Math.max(1, board.tasks.size),
-    }).rows;
+    });
     const rows = selectedRows.map(({ parent: _parent, needs: _needs, blocks: _blocks, createdAt: _createdAt, ...row }) => row);
-    return { kind: "accepted", value: projectPage(rows, limit) };
+    return { kind: "accepted", value: projectBoundedList(rows, selectedLimit) };
 }
-export async function blockedTasks(world, namespace, scope, parent, limit = DEFAULT_TASK_LIMIT) {
+export async function blockedTasks(world, namespace, scope, parent, limit) {
+    const selectedLimit = taskRowViewLimit(limit);
     const selected = readScope(namespace, scope);
     const board = (await readBoard(world)).board;
     if (parent !== undefined && !board.tasks.has(parent))
@@ -275,18 +233,18 @@ export async function blockedTasks(world, namespace, scope, parent, limit = DEFA
         predicate: { field: "blocked", operator: "=", value: true },
     };
     const expression = parent === undefined ? blocked : { kind: "and", terms: [blocked, underExpression(parent)] };
-    const selectedRows = projectQuery(board, relations, {
+    const selectedRows = projectQueryRows(board, relations, {
         scope: selected,
         expression,
-        limit: Math.max(1, board.tasks.size),
-    }).rows;
+    });
     const ids = new Set(selectedRows.map((row) => row.id));
     return {
         kind: "accepted",
-        value: projectPage(projectBlocked(board, selected, relations).filter((row) => ids.has(row.id)), limit),
+        value: projectBoundedList(projectBlocked(board, selected, relations).filter((row) => ids.has(row.id)), selectedLimit),
     };
 }
 export async function queryTasks(input) {
+    const selectedLimit = taskRowViewLimit(input.limit);
     const selected = readScope(input.namespace, input.scope);
     const board = (await readBoard(input.world)).board;
     const relations = createTaskRelations(board);
@@ -300,7 +258,7 @@ export async function queryTasks(input) {
             scope: selected,
             expression: input.expression,
             sort: input.sort ?? "priority",
-            limit: input.limit ?? DEFAULT_TASK_LIMIT,
+            limit: selectedLimit,
         }),
     };
 }

package/build/src/task/query.d.ts

@@ -1,8 +1,7 @@
 import type { TaskPriority, TaskState } from "./document.js";
 import { type TaskId } from "./identity.js";
 import type { BlockedTaskRow, TaskBoard, TaskRef, TaskRelationProjection, TaskRow } from "./board.js";
-export declare const DEFAULT_TASK_LIMIT = 100;
-export declare const MAX_TASK_LIMIT = 1000;
+import { type BoundedList } from "../bounded-list.js";
 export declare const TASK_RELATION_PREDICATE_FIELDS: readonly ["under", "needs", "blocks"];
 export type TaskRelationPredicateField = (typeof TASK_RELATION_PREDICATE_FIELDS)[number];
 export type TaskQueryComparison = "=" | "!=" | "<" | "<=" | ">" | ">=" | "~";
@@ -53,22 +52,20 @@ export type TaskQueryRow = TaskRow & Readonly<{
     createdAt: string;
     updatedAt: string;
 }>;
-export type TaskPage<Row> = Readonly<{
-    rows: readonly Row[];
-    total: number;
-    returned: number;
-    truncated: boolean;
-}>;
+export type TaskPage<Row> = BoundedList<Row>;
 export declare function normalizeTaskQuery(value: unknown): TaskQueryExpression;
+export declare function projectQueryRows(board: TaskBoard, relations: TaskRelationProjection, input: Readonly<{
+    scope: readonly string[] | null;
+    expression: TaskQueryExpression;
+    sort?: TaskQuerySort;
+}>): readonly TaskQueryRow[];
 export declare function projectQuery(board: TaskBoard, relations: TaskRelationProjection, input: Readonly<{
     scope: readonly string[] | null;
     expression: TaskQueryExpression;
     sort?: TaskQuerySort;
-    limit?: number;
+    limit: number;
 }>): TaskPage<TaskQueryRow>;
-export declare function projectPage<Row>(rows: readonly Row[], limit?: number): TaskPage<Row>;
 export declare function underExpression(parent: TaskId): TaskQueryExpression;
 export declare function queryUnderTargets(expression: TaskQueryExpression): readonly TaskId[];
-export declare function isValidTaskLimit(value: number): boolean;
 export type TaskQueryPage = TaskPage<TaskQueryRow>;
 export type TaskBlockedPage = TaskPage<BlockedTaskRow>;

package/build/src/task/query.js

@@ -1,7 +1,6 @@
 import { formatTaskId, parseTaskId, sameNamespace } from "./identity.js";
 import { projectTaskRow, taskBlocked, taskDisposition, taskRef } from "./board.js";
-export const DEFAULT_TASK_LIMIT = 100;
-export const MAX_TASK_LIMIT = 1_000;
+import { projectBoundedList } from "../bounded-list.js";
 export const TASK_RELATION_PREDICATE_FIELDS = ["under", "needs", "blocks"];
 function isTaskRelationPredicateField(value) {
     return TASK_RELATION_PREDICATE_FIELDS.includes(value);
@@ -242,18 +241,15 @@ function sortTasks(tasks, sort) {
         return (sort === "updated" ? -compared : compared) || tie;
     });
 }
-export function projectQuery(board, relations, input) {
-    const { scope, expression, sort = "priority", limit = DEFAULT_TASK_LIMIT } = input;
+export function projectQueryRows(board, relations, input) {
+    const { scope, expression, sort = "priority" } = input;
     const under = new Map(queryUnderTargets(expression).map((target) => [target, descendants(relations, target)]));
-    const selected = sortTasks([...board.tasks.values()]
+    return sortTasks([...board.tasks.values()]
         .filter((task) => scope === null || sameNamespace(parseTaskId(task.id).namespace, scope))
-        .filter((task) => matches(board, relations, task, expression, under)), sort);
-    const rows = selected.slice(0, limit).map((task) => row(board, relations, task));
-    return { rows, total: selected.length, returned: rows.length, truncated: rows.length < selected.length };
+        .filter((task) => matches(board, relations, task, expression, under)), sort).map((task) => row(board, relations, task));
 }
-export function projectPage(rows, limit = DEFAULT_TASK_LIMIT) {
-    const visible = rows.slice(0, limit);
-    return { rows: visible, total: rows.length, returned: visible.length, truncated: visible.length < rows.length };
+export function projectQuery(board, relations, input) {
+    return projectBoundedList(projectQueryRows(board, relations, input), input.limit);
 }
 export function underExpression(parent) {
     return { kind: "predicate", predicate: { field: "under", operator: "=", value: parent } };
@@ -271,6 +267,3 @@ export function queryUnderTargets(expression) {
     collect(expression);
     return [...targets];
 }
-export function isValidTaskLimit(value) {
-    return Number.isInteger(value) && value > 0 && value <= MAX_TASK_LIMIT;
-}

package/build/src/task/store.d.ts

@@ -1,4 +1,6 @@
 import type { WorldRoot } from "../world.js";
+import { type BoundedList } from "../bounded-list.js";
+import { type TaskDocument } from "./document.js";
 import { type TaskId } from "./identity.js";
 import type { TaskBoard } from "./board.js";
 export type BoardSnapshot = Readonly<{
@@ -7,11 +9,19 @@ export type BoardSnapshot = Readonly<{
 }>;
 export declare const DEFAULT_TASK_LOCK_TIMEOUT_MS = 3000;
 export declare function readBoard(world: WorldRoot): Promise<BoardSnapshot>;
+export declare function readRecentTaskDocuments(world: WorldRoot, input: Readonly<{
+    namespace?: readonly string[];
+    selection?: "all" | "active";
+    limit?: number;
+}>): Promise<BoundedList<TaskDocument>>;
+export declare function readTaskDocument(world: WorldRoot, id: TaskId): Promise<TaskDocument | undefined>;
 export declare function replaceAuthority(input: Readonly<{
-    path: string;
+    world: WorldRoot;
+    id: TaskId;
     expected: Uint8Array | null;
     next: Uint8Array;
 }>): Promise<"replaced" | "concurrent-modification">;
+export declare function authorityBytesMatch(world: WorldRoot, id: TaskId, expected: Uint8Array | null): Promise<boolean>;
 export declare function nukeTaskAuthority(world: WorldRoot, options?: Readonly<{
     timeoutMs?: number;
 }>): Promise<void | "busy">;