@astrosheep/keiyaku 4.6.8 → 4.6.9

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

@@ -0,0 +1,76 @@
+import type { DebtPriority, DebtState } from "./document.js";
+import { type DebtId } from "./identity.js";
+import type { DebtBoard, DebtRef, DebtRelationProjection, DebtRow } from "./board.js";
+import { type BoundedList } from "../bounded-list.js";
+export declare const DEBT_RELATION_PREDICATE_FIELDS: readonly ["under", "needs", "blocks"];
+export type DebtRelationPredicateField = (typeof DEBT_RELATION_PREDICATE_FIELDS)[number];
+export type DebtQueryPredicate = Readonly<{
+    field: "state";
+    operator: "=" | "!=";
+    value: DebtState;
+}> | Readonly<{
+    field: "priority";
+    operator: "=" | "!=" | "<" | "<=" | ">" | ">=";
+    value: DebtPriority;
+}> | Readonly<{
+    field: "title" | "id";
+    operator: "=" | "!=" | "~";
+    value: string;
+}> | Readonly<{
+    field: "parent";
+    operator: "=" | "!=";
+    value: DebtId | null;
+}> | Readonly<{
+    field: "under" | "needs" | "blocks";
+    operator: "=" | "!=";
+    value: DebtId;
+}> | Readonly<{
+    field: "ready" | "blocked";
+    operator: "=" | "!=";
+    value: boolean;
+}> | Readonly<{
+    field: "created" | "updated";
+    operator: "=" | "!=" | "<" | "<=" | ">" | ">=";
+    value: string;
+}>;
+export type DebtQueryExpression = Readonly<{
+    kind: "and" | "or";
+    terms: readonly DebtQueryExpression[];
+}> | Readonly<{
+    kind: "not";
+    term: DebtQueryExpression;
+}> | Readonly<{
+    kind: "predicate";
+    predicate: DebtQueryPredicate;
+}>;
+export type DebtQuerySort = "priority" | "created" | "updated" | "id";
+export type DebtQueryRow = DebtRow & Readonly<{
+    parent: DebtId | null;
+    needs: readonly DebtRef[];
+    blocks: readonly DebtRef[];
+    createdAt: string;
+    updatedAt: string;
+}>;
+export type DebtPage<Row> = BoundedList<Row>;
+/** Semantic refusals identify the caller input part; textual offsets belong to the CLI. */
+export declare class DebtQueryPredicateError extends TypeError {
+    readonly part: "field" | "operator" | "value";
+    constructor(message: string, part: "field" | "operator" | "value");
+}
+export declare function normalizeDebtQueryPredicate(value: unknown): DebtQueryPredicate;
+export declare function normalizeDebtQuery(value: unknown): DebtQueryExpression;
+/** CLI selection and native default share Debt-owned terminal-state semantics. */
+export declare function debtQuerySelection(selection?: "active" | "closed" | "all", where?: DebtQueryExpression): DebtQueryExpression;
+export declare function projectQueryRows(board: DebtBoard, relations: DebtRelationProjection, input: Readonly<{
+    scope: readonly string[] | null;
+    expression: DebtQueryExpression;
+    sort?: DebtQuerySort;
+}>): readonly DebtQueryRow[];
+export declare function projectQuery(board: DebtBoard, relations: DebtRelationProjection, input: Readonly<{
+    scope: readonly string[] | null;
+    expression: DebtQueryExpression;
+    sort?: DebtQuerySort;
+    limit: number;
+}>): DebtPage<DebtQueryRow>;
+export declare function underExpression(parent: DebtId): DebtQueryExpression;
+export declare function queryUnderTargets(expression: DebtQueryExpression): readonly DebtId[];

package/build/src/{task → debt}/query.js

@@ -1,8 +1,8 @@
-import { formatTaskId, parseTaskId, sameNamespace } from "./identity.js";
-import { projectTaskRow, taskBlocked, taskDisposition, taskRef } from "./board.js";
+import { formatDebtId, parseDebtId, sameNamespace } from "./identity.js";
+import { projectDebtRow, debtBlocked, debtDisposition, debtRef } from "./board.js";
 import { projectBoundedList } from "../bounded-list.js";
-export const TASK_RELATION_PREDICATE_FIELDS = ["under", "needs", "blocks"];
-const states = ["open", "in_progress", "on_hold", "done", "drop"];
+export const DEBT_RELATION_PREDICATE_FIELDS = ["under", "needs", "blocks"];
+const states = ["open", "done", "drop"];
 const comparisons = ["=", "!=", "<", "<=", ">", ">=", "~"];
 function fail(message) {
     throw new TypeError(message);
@@ -18,7 +18,7 @@ function closed(value, fields, label) {
             fail(`${label} has unknown field: ${key}`);
 }
 /** Semantic refusals identify the caller input part; textual offsets belong to the CLI. */
-export class TaskQueryPredicateError extends TypeError {
+export class DebtQueryPredicateError extends TypeError {
     part;
     constructor(message, part) {
         super(message);
@@ -26,18 +26,18 @@ export class TaskQueryPredicateError extends TypeError {
     }
 }
 function invalidPredicate(message, part = "value") {
-    throw new TaskQueryPredicateError(message, part);
+    throw new DebtQueryPredicateError(message, part);
 }
-function taskId(value, label) {
+function debtId(value, label) {
     if (typeof value !== "string")
-        invalidPredicate(`${label} must be a TaskId`);
+        invalidPredicate(`${label} must be a DebtId`);
     try {
-        const coordinate = parseTaskId(value);
-        if (formatTaskId(coordinate) !== value)
-            invalidPredicate(`${label} must be a canonical TaskId`);
+        const coordinate = parseDebtId(value);
+        if (formatDebtId(coordinate) !== value)
+            invalidPredicate(`${label} must be a canonical DebtId`);
     }
     catch {
-        invalidPredicate(`${label} must be a canonical TaskId`);
+        invalidPredicate(`${label} must be a canonical DebtId`);
     }
     return value;
 }
@@ -81,15 +81,15 @@ function normalizeTextPredicate(input, field, operator) {
     if (operator !== "=" && operator !== "!=" && operator !== "~")
         invalidPredicate(`${field} supports only =, !=, and ~`, "operator");
     if (field === "id" && operator !== "~")
-        taskId(input.value, "id value");
+        debtId(input.value, "id value");
     return { field, operator, value: input.value };
 }
 function normalizeParentPredicate(input, operator) {
-    const value = input.value === null ? null : taskId(input.value, "parent value");
+    const value = input.value === null ? null : debtId(input.value, "parent value");
     return { field: "parent", operator: equalityOperator(operator, "parent"), value };
 }
 function normalizeRelationPredicate(input, field, operator) {
-    return { field, operator: equalityOperator(operator, field), value: taskId(input.value, `${field} value`) };
+    return { field, operator: equalityOperator(operator, field), value: debtId(input.value, `${field} value`) };
 }
 function normalizeBooleanPredicate(input, field, operator) {
     if (typeof input.value !== "boolean")
@@ -99,7 +99,7 @@ function normalizeBooleanPredicate(input, field, operator) {
 function normalizeTimestampPredicate(input, field, operator) {
     return { field, operator: orderedOperator(operator, field), value: timestamp(input.value, `${field} value`) };
 }
-export function normalizeTaskQueryPredicate(value) {
+export function normalizeDebtQueryPredicate(value) {
     const input = object(value, "query predicate");
     closed(input, ["field", "operator", "value"], "query predicate");
     const field = input.field;
@@ -131,26 +131,26 @@ export function normalizeTaskQueryPredicate(value) {
             return invalidPredicate(`unknown query field: ${field}`, "field");
     }
 }
-export function normalizeTaskQuery(value) {
+export function normalizeDebtQuery(value) {
     const input = object(value, "query expression");
     if (input.kind === "predicate") {
         closed(input, ["kind", "predicate"], "query expression");
-        return { kind: "predicate", predicate: normalizeTaskQueryPredicate(input.predicate) };
+        return { kind: "predicate", predicate: normalizeDebtQueryPredicate(input.predicate) };
     }
     if (input.kind === "not") {
         closed(input, ["kind", "term"], "query expression");
-        return { kind: "not", term: normalizeTaskQuery(input.term) };
+        return { kind: "not", term: normalizeDebtQuery(input.term) };
     }
     if (input.kind === "and" || input.kind === "or") {
         closed(input, ["kind", "terms"], "query expression");
         if (!Array.isArray(input.terms) || input.terms.length === 0)
             fail(`${input.kind} query requires terms`);
-        return { kind: input.kind, terms: input.terms.map((term) => normalizeTaskQuery(term)) };
+        return { kind: input.kind, terms: input.terms.map((term) => normalizeDebtQuery(term)) };
     }
     fail("query expression kind is invalid");
 }
-/** CLI selection and native default share Task-owned terminal-state semantics. */
-export function taskQuerySelection(selection = "active", where) {
+/** CLI selection and native default share Debt-owned terminal-state semantics. */
+export function debtQuerySelection(selection = "active", where) {
     if (selection === "all" && where !== undefined)
         return where;
     const state = (value, operator) => ({
@@ -194,10 +194,10 @@ function descendants(relations, parent) {
     return result;
 }
 function relation(board, relations, id, field, target) {
-    const task = board.tasks.get(id);
-    if (task === undefined)
+    const debt = board.debts.get(id);
+    if (debt === undefined)
         return false;
-    return field === "needs" ? task.needs.includes(target) : relations.blocks(id).some((ref) => ref.id === target);
+    return field === "needs" ? debt.needs.includes(target) : relations.blocks(id).some((ref) => ref.id === target);
 }
 function matchText(left, operator, right) {
     return operator === "~" ? left.includes(right) : compare(left, operator, right);
@@ -205,56 +205,56 @@ function matchText(left, operator, right) {
 function matchRelation(selected, operator) {
     return operator === "=" ? selected : !selected;
 }
-function matchesPredicate(board, relations, task, value, under) {
+function matchesPredicate(board, relations, debt, value, under) {
     switch (value.field) {
         case "state":
-            return compare(task.state, value.operator, value.value);
+            return compare(debt.state, value.operator, value.value);
         case "priority":
-            return compare(task.priority, value.operator, value.value);
+            return compare(debt.priority, value.operator, value.value);
         case "title":
-            return matchText(task.title, value.operator, value.value);
+            return matchText(debt.title, value.operator, value.value);
         case "id":
-            return matchText(task.id, value.operator, value.value);
+            return matchText(debt.id, value.operator, value.value);
         case "parent":
-            return compare(task.parent ?? "", value.operator, value.value ?? "");
+            return compare(debt.parent ?? "", value.operator, value.value ?? "");
         case "under":
-            return matchRelation(under.get(value.value)?.has(task.id) === true, value.operator);
+            return matchRelation(under.get(value.value)?.has(debt.id) === true, value.operator);
         case "needs":
-            return matchRelation(relation(board, relations, task.id, "needs", value.value), value.operator);
+            return matchRelation(relation(board, relations, debt.id, "needs", value.value), value.operator);
         case "blocks":
-            return matchRelation(relation(board, relations, task.id, "blocks", value.value), value.operator);
+            return matchRelation(relation(board, relations, debt.id, "blocks", value.value), value.operator);
         case "ready":
-            return membership(taskDisposition(board, task) === "ready", value.operator, value.value);
+            return membership(debtDisposition(board, debt) === "ready", value.operator, value.value);
         case "blocked":
-            return membership(taskBlocked(board, task), value.operator, value.value);
+            return membership(debtBlocked(board, debt), value.operator, value.value);
         case "created":
-            return compare(task.createdAt, value.operator, value.value);
+            return compare(debt.createdAt, value.operator, value.value);
         case "updated":
-            return compare(task.updatedAt, value.operator, value.value);
+            return compare(debt.updatedAt, value.operator, value.value);
     }
 }
-function matches(board, relations, task, expression, under) {
+function matches(board, relations, debt, expression, under) {
     if (expression.kind === "not")
-        return !matches(board, relations, task, expression.term, under);
+        return !matches(board, relations, debt, expression.term, under);
     if (expression.kind !== "predicate") {
         return expression.kind === "and"
-            ? expression.terms.every((term) => matches(board, relations, task, term, under))
-            : expression.terms.some((term) => matches(board, relations, task, term, under));
+            ? expression.terms.every((term) => matches(board, relations, debt, term, under))
+            : expression.terms.some((term) => matches(board, relations, debt, term, under));
     }
-    return matchesPredicate(board, relations, task, expression.predicate, under);
+    return matchesPredicate(board, relations, debt, expression.predicate, under);
 }
-function row(board, relations, task) {
+function row(board, relations, debt) {
     return {
-        ...projectTaskRow(board, relations, task),
-        parent: task.parent,
-        needs: task.needs.map((need) => taskRef(board, need)),
-        blocks: relations.blocks(task.id),
-        createdAt: task.createdAt,
-        updatedAt: task.updatedAt,
+        ...projectDebtRow(board, relations, debt),
+        parent: debt.parent,
+        needs: debt.needs.map((need) => debtRef(board, need)),
+        blocks: relations.blocks(debt.id),
+        createdAt: debt.createdAt,
+        updatedAt: debt.updatedAt,
     };
 }
-function sortTasks(tasks, sort) {
-    return [...tasks].sort((left, right) => {
+function sortDebts(debts, sort) {
+    return [...debts].sort((left, right) => {
         const tie = Buffer.compare(Buffer.from(left.id), Buffer.from(right.id));
         if (sort === "id")
             return tie;
@@ -267,9 +267,9 @@ function sortTasks(tasks, sort) {
 export function projectQueryRows(board, relations, input) {
     const { scope, expression, sort = "priority" } = input;
     const under = new Map(queryUnderTargets(expression).map((target) => [target, descendants(relations, target)]));
-    return sortTasks([...board.tasks.values()]
-        .filter((task) => scope === null || sameNamespace(parseTaskId(task.id).namespace, scope))
-        .filter((task) => matches(board, relations, task, expression, under)), sort).map((task) => row(board, relations, task));
+    return sortDebts([...board.debts.values()]
+        .filter((debt) => scope === null || sameNamespace(parseDebtId(debt.id).namespace, scope))
+        .filter((debt) => matches(board, relations, debt, expression, under)), sort).map((debt) => row(board, relations, debt));
 }
 export function projectQuery(board, relations, input) {
     return projectBoundedList(projectQueryRows(board, relations, input), input.limit);

package/build/src/{task → debt}/store.d.ts

@@ -1,34 +1,34 @@
 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";
+import { type DebtDocument } from "./document.js";
+import { type DebtId } from "./identity.js";
+import type { DebtBoard } from "./board.js";
 export type BoardSnapshot = Readonly<{
-    board: TaskBoard;
-    bytes: ReadonlyMap<TaskId, Uint8Array>;
+    board: DebtBoard;
+    bytes: ReadonlyMap<DebtId, Uint8Array>;
 }>;
 export declare function readBoard(world: WorldRoot): Promise<BoardSnapshot>;
-export declare function readRecentTaskDocuments(world: WorldRoot, input: Readonly<{
+export declare function readRecentDebtDocuments(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>;
+}>): Promise<BoundedList<DebtDocument>>;
+export declare function readDebtDocument(world: WorldRoot, id: DebtId): Promise<DebtDocument | undefined>;
 export declare function replaceAuthority(input: Readonly<{
     world: WorldRoot;
-    id: TaskId;
+    id: DebtId;
     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<{
+export declare function authorityBytesMatch(world: WorldRoot, id: DebtId, expected: Uint8Array | null): Promise<boolean>;
+export declare function nukeDebtAuthority(world: WorldRoot, options?: Readonly<{
     timeoutMs?: number;
     onRemoved?(count: number): void;
 }>): Promise<number | "busy">;
-export declare function withTaskLocks<T>(input: Readonly<{
+export declare function withDebtLocks<T>(input: Readonly<{
     world: WorldRoot;
     allocation: boolean;
-    ids: readonly TaskId[];
+    ids: readonly DebtId[];
     timeoutMs?: number;
     signal?: AbortSignal;
 }>, action: () => Promise<T>): Promise<T | "busy">;

package/build/src/{task → debt}/store.js

@@ -5,17 +5,26 @@ import { dirname, relative, resolve, sep } from "node:path";
 import { acquireSqliteTransactionLock, SqliteTransactionLockError, } from "../coordination/sqlite-transaction-lock.js";
 import { syncDirectory } from "../coordination/durable-file.js";
 import { boundedListLimit, projectBoundedList } from "../bounded-list.js";
-import { parseTaskDocument } from "./document.js";
-import { formatTaskId, parseTaskId, physicalTaskSegment, TASK_LOCAL_ID_BYTES, sameNamespace, taskAuthorityPath, } from "./identity.js";
-const DEFAULT_TASK_LOCK_TIMEOUT_MS = 3_000;
-function tasksDirectory(world) {
-    return resolve(world, ".keiyaku", "tasks");
+import { parseDebtDocument } from "./document.js";
+import { formatDebtId, parseDebtId, physicalDebtSegment, DEBT_LOCAL_ID_BYTES, sameNamespace, debtAuthorityPath, } from "./identity.js";
+const DEFAULT_DEBT_LOCK_TIMEOUT_MS = 3_000;
+async function debtsDirectory(world) {
+    const legacy = resolve(world, ".keiyaku", "tasks");
+    try {
+        await lstat(legacy);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+        return resolve(world, ".keiyaku", "debts");
+    }
+    throw new Error(`Unmigrated ledger authority: ${legacy}`);
 }
 function allocationLockPath(world) {
-    return resolve(world, ".keiyaku", "locks", "task-allocation.sqlite");
+    return resolve(world, ".keiyaku", "locks", "debt-allocation.sqlite");
 }
 function custodyError(path) {
-    return new Error(`Task authority custody violation: symlink or non-authority component: ${path}`);
+    return new Error(`Debt authority custody violation: symlink or non-authority component: ${path}`);
 }
 async function requireDirectory(path, mode) {
     try {
@@ -44,14 +53,14 @@ async function requireDirectory(path, mode) {
     }
 }
 async function resolveAuthority(world, id, mode) {
-    const coordinate = parseTaskId(id);
-    const root = tasksDirectory(world);
-    const safePath = taskAuthorityPath(root, coordinate);
+    const coordinate = parseDebtId(id);
+    const root = await debtsDirectory(world);
+    const safePath = debtAuthorityPath(root, coordinate);
     if (!(await requireDirectory(root, mode)))
         return { path: safePath, exists: false };
     let parent = root;
     for (const segment of coordinate.namespace) {
-        parent = resolve(parent, physicalTaskSegment(segment));
+        parent = resolve(parent, physicalDebtSegment(segment));
         if (!(await requireDirectory(parent, mode)))
             return { path: safePath, exists: false };
     }
@@ -85,27 +94,27 @@ async function authorityFiles(directory) {
     }
     return files.sort((a, b) => Buffer.compare(Buffer.from(a), Buffer.from(b)));
 }
-function coordinateFromPath(tasksDirectory, path) {
-    const local = relative(tasksDirectory, path);
-    if (local.startsWith("..") || resolve(tasksDirectory, local) !== path || !local.endsWith(".md"))
-        throw new Error(`invalid Task authority path: ${path}`);
+function coordinateFromPath(debtsDirectory, path) {
+    const local = relative(debtsDirectory, path);
+    if (local.startsWith("..") || resolve(debtsDirectory, local) !== path || !local.endsWith(".md"))
+        throw new Error(`invalid Debt authority path: ${path}`);
     const segments = local.slice(0, -3).split(sep);
-    segments.forEach((segment) => physicalTaskSegment(segment));
-    return parseTaskId(`task/${segments.join("/")}`);
+    segments.forEach((segment) => physicalDebtSegment(segment));
+    return parseDebtId(`debt/${segments.join("/")}`);
 }
 async function ownedAuthorityCandidates(directory) {
     const candidates = [];
     for (const path of await authorityFiles(directory)) {
         try {
-            candidates.push({ id: formatTaskId(coordinateFromPath(directory, path)), path });
+            candidates.push({ id: formatDebtId(coordinateFromPath(directory, path)), path });
         }
         catch {
-            // Files outside the Task identity grammar are not owned candidates.
+            // Files outside the Debt identity grammar are not owned candidates.
         }
     }
     return candidates;
 }
-async function removeEmptyTaskDirectories(directory, removeSelf) {
+async function removeEmptyDebtDirectories(directory, removeSelf) {
     if (!(await requireDirectory(directory, "read")))
         return;
     const entries = await readdir(directory);
@@ -115,7 +124,7 @@ async function removeEmptyTaskDirectories(directory, removeSelf) {
         if (stat.isSymbolicLink())
             throw custodyError(path);
         if (stat.isDirectory())
-            await removeEmptyTaskDirectories(path, true);
+            await removeEmptyDebtDirectories(path, true);
     }
     if (!removeSelf)
         return;
@@ -129,7 +138,7 @@ async function removeEmptyTaskDirectories(directory, removeSelf) {
     }
 }
 export async function readBoard(world) {
-    const directory = tasksDirectory(world);
+    const directory = await debtsDirectory(world);
     const paths = await authorityFiles(directory);
     const reads = new Array(paths.length);
     let next = 0;
@@ -140,7 +149,7 @@ export async function readBoard(world) {
             try {
                 const stat = await lstat(path);
                 if (!stat.isFile() || stat.isSymbolicLink()) {
-                    throw new Error(`Task authority is not a regular file: ${path}`);
+                    throw new Error(`Debt authority is not a regular file: ${path}`);
                 }
                 const coordinate = coordinateFromPath(directory, path);
                 reads[index] = { kind: "read", coordinate, source: await readFile(path) };
@@ -152,43 +161,43 @@ export async function readBoard(world) {
     };
     // Drain all owned reads; authority and errors are then judged in canonical path order.
     await Promise.all(Array.from({ length: Math.min(8, paths.length) }, worker));
-    const tasks = new Map();
+    const debts = new Map();
     const bytes = new Map();
     for (const read of reads) {
         if (read.kind === "failed")
             throw read.error;
         const { coordinate, source } = read;
-        const id = formatTaskId(coordinate);
-        tasks.set(id, parseTaskDocument(source, coordinate));
+        const id = formatDebtId(coordinate);
+        debts.set(id, parseDebtDocument(source, coordinate));
         bytes.set(id, source);
     }
-    return { board: { tasks }, bytes };
+    return { board: { debts }, bytes };
 }
-function compareRecentTasks(left, right) {
+function compareRecentDebts(left, right) {
     const updated = right.updatedAt.localeCompare(left.updatedAt);
     return updated === 0 ? Buffer.compare(Buffer.from(left.id), Buffer.from(right.id)) : updated;
 }
-export async function readRecentTaskDocuments(world, input) {
+export async function readRecentDebtDocuments(world, input) {
     const limit = boundedListLimit(input.limit);
-    const directory = tasksDirectory(world);
-    const tasks = [];
+    const directory = await debtsDirectory(world);
+    const debts = [];
     for (const path of await authorityFiles(directory)) {
         const metadata = await lstat(path);
         if (!metadata.isFile() || metadata.isSymbolicLink())
-            throw new Error(`Task authority is not a regular file: ${path}`);
+            throw new Error(`Debt authority is not a regular file: ${path}`);
         const coordinate = coordinateFromPath(directory, path);
         if (input.namespace !== undefined && !sameNamespace(coordinate.namespace, input.namespace))
             continue;
-        const task = parseTaskDocument(await readFile(path), coordinate);
-        if (input.selection === "active" && (task.state === "done" || task.state === "drop"))
+        const debt = parseDebtDocument(await readFile(path), coordinate);
+        if (input.selection === "active" && (debt.state === "done" || debt.state === "drop"))
             continue;
-        tasks.push(task);
+        debts.push(debt);
     }
-    return projectBoundedList(tasks.sort(compareRecentTasks), limit);
+    return projectBoundedList(debts.sort(compareRecentDebts), limit);
 }
-export async function readTaskDocument(world, id) {
+export async function readDebtDocument(world, id) {
     const resolved = await resolveAuthority(world, id, "read");
-    return resolved.exists ? parseTaskDocument(await readFile(resolved.path), parseTaskId(id)) : undefined;
+    return resolved.exists ? parseDebtDocument(await readFile(resolved.path), parseDebtId(id)) : undefined;
 }
 function equal(left, right) {
     return left === null || right === null ? left === right : Buffer.from(left).equals(Buffer.from(right));
@@ -229,8 +238,8 @@ export async function authorityBytesMatch(world, id, expected) {
     return equal(await currentBytes(world, id), expected);
 }
 function lockPath(world, id) {
-    const coordinate = parseTaskId(id);
-    return resolve(world, ".keiyaku", "locks", "task", ...coordinate.namespace.map((segment) => physicalTaskSegment(segment)), `${physicalTaskSegment(coordinate.localId, TASK_LOCAL_ID_BYTES)}.sqlite`);
+    const coordinate = parseDebtId(id);
+    return resolve(world, ".keiyaku", "locks", "debt", ...coordinate.namespace.map((segment) => physicalDebtSegment(segment)), `${physicalDebtSegment(coordinate.localId, DEBT_LOCAL_ID_BYTES)}.sqlite`);
 }
 function errorDetail(error) {
     return error instanceof Error ? error.message : String(error);
@@ -249,15 +258,15 @@ function preserveCommittedResult(result, errors) {
             };
         }
     }
-    throw new AggregateError(errors, "Task lock cleanup failed");
+    throw new AggregateError(errors, "Debt lock cleanup failed");
 }
-export async function nukeTaskAuthority(world, options) {
-    const directory = tasksDirectory(world);
+export async function nukeDebtAuthority(world, options) {
+    const directory = await debtsDirectory(world);
     const lockOptions = options?.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs };
-    const result = await withTaskLocks({ world, allocation: true, ids: [], ...lockOptions }, async () => {
+    const result = await withDebtLocks({ world, allocation: true, ids: [], ...lockOptions }, async () => {
         const candidates = await ownedAuthorityCandidates(directory);
         const ids = [...new Set(candidates.map((candidate) => candidate.id))].sort((left, right) => Buffer.compare(Buffer.from(left), Buffer.from(right)));
-        return await withTaskLocks({ world, allocation: false, ids, ...lockOptions }, async () => {
+        return await withDebtLocks({ world, allocation: false, ids, ...lockOptions }, async () => {
             let removed = 0;
             for (const candidate of candidates) {
                 try {
@@ -273,7 +282,7 @@ export async function nukeTaskAuthority(world, options) {
                         throw error;
                 }
             }
-            await removeEmptyTaskDirectories(directory, false);
+            await removeEmptyDebtDirectories(directory, false);
             return removed;
         });
     });
@@ -281,7 +290,7 @@ export async function nukeTaskAuthority(world, options) {
         return "busy";
     return result;
 }
-export async function withTaskLocks(input, action) {
+export async function withDebtLocks(input, action) {
     const paths = [
         ...(input.allocation ? [allocationLockPath(input.world)] : []),
         ...[...new Set(input.ids)]
@@ -296,7 +305,7 @@ export async function withTaskLocks(input, action) {
             held.push(await acquireSqliteTransactionLock({
                 path,
                 mode: "immediate",
-                timeoutMs: input.timeoutMs ?? DEFAULT_TASK_LOCK_TIMEOUT_MS,
+                timeoutMs: input.timeoutMs ?? DEFAULT_DEBT_LOCK_TIMEOUT_MS,
                 ...(input.signal === undefined ? {} : { signal: input.signal }),
             }));
         result = await action();
@@ -318,7 +327,7 @@ export async function withTaskLocks(input, action) {
             if (failure === undefined && result !== undefined)
                 result = preserveCommittedResult(result, cleanupErrors);
             else if (failure === undefined)
-                failure = new AggregateError(cleanupErrors, "Task lock cleanup failed");
+                failure = new AggregateError(cleanupErrors, "Debt lock cleanup failed");
             else {
                 const originalFailure = failure;
                 failure = new AggregateError([originalFailure, ...cleanupErrors], errorDetail(originalFailure), {

package/build/src/debt/view.d.ts

@@ -0,0 +1,4 @@
+import type { DebtDocument } from "./document.js";
+import type { DebtView } from "./operation-types.js";
+export declare function debtView(document: DebtDocument): DebtView;
+export declare function advanceDebtTimestamp(previous: string, candidate: string): string;

package/build/src/debt/view.js

@@ -0,0 +1,7 @@
+import { parseDebtId } from "./identity.js";
+export function debtView(document) {
+    return { ...document, namespace: parseDebtId(document.id).namespace };
+}
+export function advanceDebtTimestamp(previous, candidate) {
+    return candidate > previous ? candidate : new Date(Date.parse(previous) + 1).toISOString();
+}

package/build/src/identity/coordinates.d.ts

@@ -1,4 +1,4 @@
-export type IdentityFamily = "aku" | "kei" | "task" | "resp";
+export type IdentityFamily = "aku" | "kei" | "debt" | "resp";
 export declare function identityCoordinate(input: Readonly<{
     family: IdentityFamily;
     segments: readonly string[];