@astrosheep/keiyaku 4.6.8 → 4.6.9

package/build/src/{task → debt}/created-observation.js

@@ -1,20 +1,20 @@
 import { z } from "zod";
-import { createTaskRelations, projectCreatedByRows, taskRowsSchema } from "./board.js";
+import { createDebtRelations, projectCreatedByRows, debtRowsSchema } from "./board.js";
 import { readBoard } from "./store.js";
-export const createdTaskObservationSchema = z.union([
-    z.object({ kind: z.literal("present"), rows: taskRowsSchema }).strict(),
+export const createdDebtObservationSchema = z.union([
+    z.object({ kind: z.literal("present"), rows: debtRowsSchema }).strict(),
     z.object({ kind: z.literal("failed"), diagnostic: z.string() }).strict(),
 ]);
-export const EMPTY_CREATED_TASK_OBSERVATION = { kind: "present", rows: [] };
+export const EMPTY_CREATED_DEBT_OBSERVATION = { kind: "present", rows: [] };
 function observationDiagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
 /**
- * Project Task board rows created by each identity, preserving input order. One complete
+ * Project Debt board rows created by each identity, preserving input order. One complete
  * board and one relationship projection answer every requested identity, and only the
  * documents those identities created reach row projection.
  */
-export async function observeCreatedTaskObservations(world, createdByIds) {
+export async function observeCreatedDebtObservations(world, createdByIds) {
     if (createdByIds.length === 0)
         return [];
     let board;
@@ -25,6 +25,6 @@ export async function observeCreatedTaskObservations(world, createdByIds) {
         const failed = { kind: "failed", diagnostic: observationDiagnostic(error) };
         return createdByIds.map(() => failed);
     }
-    const rows = projectCreatedByRows(board, createTaskRelations(board), createdByIds);
+    const rows = projectCreatedByRows(board, createDebtRelations(board), createdByIds);
     return createdByIds.map((createdBy) => ({ kind: "present", rows: rows.get(createdBy) ?? [] }));
 }

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

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { type DebtCoordinate, type DebtId } from "./identity.js";
+export declare const debtNonblankTextSchema: z.ZodString;
+export declare const debtStateSchema: z.ZodEnum<{
+    open: "open";
+    done: "done";
+    drop: "drop";
+}>;
+export declare const debtPrioritySchema: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
+export type DebtState = z.infer<typeof debtStateSchema>;
+export type DebtPriority = z.infer<typeof debtPrioritySchema>;
+export type DebtDocument = Readonly<{
+    id: DebtId;
+    title: string;
+    state: DebtState;
+    priority: DebtPriority;
+    needs: readonly DebtId[];
+    parent: DebtId | null;
+    supersedes: readonly DebtId[];
+    relates: readonly DebtId[];
+    note: string;
+    createdBy?: string;
+    createdAt: string;
+    updatedAt: string;
+    body: string;
+}>;
+export type DebtCreationDocument = Omit<DebtDocument, "id" | "createdBy" | "createdAt" | "updatedAt">;
+export declare class DebtAuthorityCorruptionError extends Error {
+    /** The Debt document whose bytes failed decode, when the reader knew its coordinate. */
+    readonly coordinate?: DebtId;
+    constructor(message: string, options?: ErrorOptions & {
+        coordinate?: DebtId;
+    });
+}
+export declare function parseDebtDocument(bytes: Uint8Array, expected: DebtCoordinate): DebtDocument;
+export declare function parseDebtCreationDocument(markdown: string): DebtCreationDocument;
+export declare function serializeDebtDocument(document: DebtDocument): Uint8Array;

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

@@ -1,20 +1,20 @@
 import { isMap, parseDocument, stringify } from "yaml";
 import { z } from "zod";
-import { formatTaskId, parseTaskId } from "./identity.js";
-export const taskNonblankTextSchema = z.string().refine((value) => value.trim() !== "");
-export const taskStateSchema = z.enum(["open", "in_progress", "on_hold", "done", "drop"]);
-export const taskPrioritySchema = z.union([z.literal(0), z.literal(1), z.literal(2), z.literal(3)]);
-export class TaskAuthorityCorruptionError extends Error {
-    /** The Task document whose bytes failed decode, when the reader knew its coordinate. */
+import { formatDebtId, parseDebtId } from "./identity.js";
+export const debtNonblankTextSchema = z.string().refine((value) => value.trim() !== "");
+export const debtStateSchema = z.enum(["open", "done", "drop"]);
+export const debtPrioritySchema = z.union([z.literal(0), z.literal(1), z.literal(2), z.literal(3)]);
+export class DebtAuthorityCorruptionError extends Error {
+    /** The Debt document whose bytes failed decode, when the reader knew its coordinate. */
     coordinate;
     constructor(message, options) {
         super(message, options);
-        this.name = "TaskAuthorityCorruptionError";
+        this.name = "DebtAuthorityCorruptionError";
         if (options?.coordinate !== undefined)
             this.coordinate = options.coordinate;
     }
 }
-const STATES = new Set(["open", "in_progress", "on_hold", "done", "drop"]);
+const STATES = new Set(["open", "done", "drop"]);
 const REQUIRED_STORED_KEYS = [
     "id",
     "title",
@@ -32,41 +32,41 @@ const STORED_KEYS = [...REQUIRED_STORED_KEYS, "createdBy"];
 const CREATION_KEYS = ["title", "state", "priority", "needs", "parent", "supersedes", "relates", "note"];
 function frontMatter(markdown, fail) {
     if (!markdown.startsWith("---\n"))
-        fail("task document must begin with YAML front matter");
+        fail("debt document must begin with YAML front matter");
     const end = markdown.indexOf("\n---\n", 4);
     if (end < 0)
-        fail("task document front matter is not closed");
+        fail("debt document front matter is not closed");
     const source = markdown.slice(4, end);
     const parsed = parseDocument(source, { merge: false, prettyErrors: false, strict: true, uniqueKeys: true });
     if (parsed.errors.length > 0 || parsed.warnings.length > 0 || !isMap(parsed.contents)) {
-        fail("task front matter must be one strict YAML mapping", parsed.errors[0]);
+        fail("debt front matter must be one strict YAML mapping", parsed.errors[0]);
     }
     const value = parsed.toJS({ maxAliasCount: 0 });
     if (typeof value !== "object" || value === null || Array.isArray(value))
-        fail("task front matter must be a mapping");
+        fail("debt front matter must be a mapping");
     return { value: value, body: markdown.slice(end + 5) };
 }
 function closed(value, allowed, required, fail) {
     for (const key of Object.keys(value))
         if (!allowed.includes(key))
-            fail(`unknown task front matter key: ${key}`);
+            fail(`unknown debt front matter key: ${key}`);
     for (const key of required)
         if (!Object.hasOwn(value, key))
-            fail(`task front matter is missing ${key}`);
+            fail(`debt front matter is missing ${key}`);
 }
 function title(value, fail) {
     if (typeof value !== "string" || value.trim().length === 0)
-        fail("task title must be a nonblank string");
+        fail("debt title must be a nonblank string");
     return value;
 }
 function priority(value, fail) {
     if (!Number.isInteger(value) || typeof value !== "number" || value < 0 || value > 3)
-        fail("task priority must be 0, 1, 2, or 3");
+        fail("debt priority must be 0, 1, 2, or 3");
     return value;
 }
 function state(value, fail) {
     if (typeof value !== "string" || !STATES.has(value))
-        fail("task state is invalid");
+        fail(`debt state is invalid: ${String(value)}`);
     return value;
 }
 function timestamp(value, field, fail) {
@@ -75,27 +75,27 @@ function timestamp(value, field, fail) {
         fail(`${field} must be a canonical UTC ISO timestamp`);
     return value;
 }
-function taskId(value, field, fail) {
+function debtId(value, field, fail) {
     if (typeof value !== "string")
-        fail(`${field} must be a TaskId`);
+        fail(`${field} must be a DebtId`);
     try {
-        parseTaskId(value);
+        parseDebtId(value);
         return value;
     }
     catch {
-        return fail(`${field} must be a canonical TaskId`);
+        return fail(`${field} must be a canonical DebtId`);
     }
 }
-function taskIds(value, field, fail) {
+function debtIds(value, field, fail) {
     if (!Array.isArray(value))
         fail(`${field} must be an array`);
-    const ids = value.map((item) => taskId(item, field, fail));
+    const ids = value.map((item) => debtId(item, field, fail));
     if (new Set(ids).size !== ids.length)
         fail(`${field} must not contain duplicates`);
     return ids;
 }
-function nullableTaskId(value, field, fail) {
-    return value === null ? null : taskId(value, field, fail);
+function nullableDebtId(value, field, fail) {
+    return value === null ? null : debtId(value, field, fail);
 }
 function createdBy(value, fail) {
     if (typeof value !== "string" || value.trim().length === 0)
@@ -106,24 +106,24 @@ function fields(value, body, fail) {
     return {
         title: title(value.title, fail),
         priority: priority(value.priority, fail),
-        needs: taskIds(value.needs, "needs", fail),
-        parent: nullableTaskId(value.parent, "parent", fail),
-        supersedes: taskIds(value.supersedes, "supersedes", fail),
-        relates: taskIds(value.relates, "relates", fail),
+        needs: debtIds(value.needs, "needs", fail),
+        parent: nullableDebtId(value.parent, "parent", fail),
+        supersedes: debtIds(value.supersedes, "supersedes", fail),
+        relates: debtIds(value.relates, "relates", fail),
         note: typeof value.note === "string" ? value.note : fail("note must be a string"),
         body,
     };
 }
-export function parseTaskDocument(bytes, expected) {
-    const coordinate = formatTaskId(expected);
+export function parseDebtDocument(bytes, expected) {
+    const coordinate = formatDebtId(expected);
     const fail = (message, cause) => {
-        throw new TaskAuthorityCorruptionError(message, { coordinate, ...(cause === undefined ? {} : { cause }) });
+        throw new DebtAuthorityCorruptionError(message, { coordinate, ...(cause === undefined ? {} : { cause }) });
     };
     const { value, body } = frontMatter(Buffer.from(bytes).toString("utf8"), fail);
     closed(value, STORED_KEYS, REQUIRED_STORED_KEYS, fail);
-    const id = taskId(value.id, "id", fail);
-    if (id !== formatTaskId(expected))
-        fail(`task document ID ${id} does not match its authority path`);
+    const id = debtId(value.id, "id", fail);
+    if (id !== formatDebtId(expected))
+        fail(`debt document ID ${id} does not match its authority path`);
     const createdAt = timestamp(value.createdAt, "createdAt", fail), updatedAt = timestamp(value.updatedAt, "updatedAt", fail);
     if (Date.parse(updatedAt) < Date.parse(createdAt))
         fail("updatedAt must not precede createdAt");
@@ -136,7 +136,7 @@ export function parseTaskDocument(bytes, expected) {
         ...(Object.hasOwn(value, "createdBy") ? { createdBy: createdBy(value.createdBy, fail) } : {}),
     };
 }
-export function parseTaskCreationDocument(markdown) {
+export function parseDebtCreationDocument(markdown) {
     const fail = (message) => {
         throw new TypeError(message);
     };
@@ -154,7 +154,7 @@ export function parseTaskCreationDocument(markdown) {
     };
     return { state: state(complete.state, fail), ...fields(complete, body, fail) };
 }
-export function serializeTaskDocument(document) {
+export function serializeDebtDocument(document) {
     const value = {
         id: document.id,
         title: document.title,

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

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import { type ContractId } from "../core/facts/types.js";
+export type DebtId = `debt/${string}`;
+export type DebtCoordinate = Readonly<{
+    namespace: readonly string[];
+    localId: string;
+}>;
+export declare const DEBT_LOCAL_ID_BYTES: number;
+export declare function isDebtSegment(value: string): boolean;
+export declare function parseDebtId(value: string): DebtCoordinate;
+export declare function formatDebtId(coordinate: DebtCoordinate): DebtId;
+export declare function canonicalDebtId(value: string): DebtId;
+export declare const debtIdSchema: z.ZodPipe<z.ZodString, z.ZodTransform<`debt/${string}`, string>>;
+export declare const debtNamespaceSchema: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+export declare const debtIdsSchema: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`debt/${string}`, string>>>>;
+export declare function contractNamespace(id: ContractId): readonly string[];
+export declare function debtAuthorityPath(debtsDirectory: string, coordinate: DebtCoordinate): string;
+export declare function deriveLocalStem(title: string): string;
+export declare function allocateLocalId(stem: string, occupied: ReadonlySet<string>): string;
+export declare function physicalDebtSegment(segment: string, maxBytes?: number): string;
+export declare function sameNamespace(left: readonly string[], right: readonly string[]): boolean;

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

@@ -5,72 +5,72 @@ import { contractSegment } from "../core/facts/types.js";
 import { identityCoordinate, identitySegments } from "../identity/coordinates.js";
 import { fitIdentityStem, normalizeIdentityStem } from "../identity/normalize.js";
 const STEM_CODE_POINTS = 32;
-const TASK_FILENAME_BYTES = 255;
-const TASK_EXTENSION_BYTES = Buffer.byteLength(".md");
-const TASK_LOCK_EXTENSION_BYTES = Buffer.byteLength(".sqlite");
+const DEBT_FILENAME_BYTES = 255;
+const DEBT_EXTENSION_BYTES = Buffer.byteLength(".md");
+const DEBT_LOCK_EXTENSION_BYTES = Buffer.byteLength(".sqlite");
 const GENERATED_SUFFIX = "-0000";
-export const TASK_LOCAL_ID_BYTES = TASK_FILENAME_BYTES - TASK_EXTENSION_BYTES - TASK_LOCK_EXTENSION_BYTES - Buffer.byteLength(GENERATED_SUFFIX);
-const GENERATED_STEM_BYTES = TASK_LOCAL_ID_BYTES - Buffer.byteLength(GENERATED_SUFFIX);
+export const DEBT_LOCAL_ID_BYTES = DEBT_FILENAME_BYTES - DEBT_EXTENSION_BYTES - DEBT_LOCK_EXTENSION_BYTES - Buffer.byteLength(GENERATED_SUFFIX);
+const GENERATED_STEM_BYTES = DEBT_LOCAL_ID_BYTES - Buffer.byteLength(GENERATED_SUFFIX);
 const WINDOWS_RESERVED = /^(?:con|prn|aux|nul|clock\$|com[1-9]|lpt[1-9])(?:\..*)?$/iu;
-export function isTaskSegment(value) {
+export function isDebtSegment(value) {
     return (value.length > 0 &&
         value !== "." &&
         value !== ".." &&
         !value.includes("/") &&
         normalizeIdentityStem({ source: value }) === value);
 }
-export function parseTaskId(value) {
+export function parseDebtId(value) {
     let segments;
     try {
-        segments = identitySegments({ family: "task", value });
+        segments = identitySegments({ family: "debt", value });
     }
     catch {
-        throw new TypeError("task ID must be task/<local-id> or task/<namespace...>/<local-id>");
+        throw new TypeError("debt ID must be debt/<local-id> or debt/<namespace...>/<local-id>");
     }
-    if (!segments.every(isTaskSegment))
-        throw new TypeError("task ID contains a noncanonical segment");
+    if (!segments.every(isDebtSegment))
+        throw new TypeError("debt ID contains a noncanonical segment");
     return { namespace: segments.slice(0, -1), localId: segments.at(-1) };
 }
-export function formatTaskId(coordinate) {
-    if (![...coordinate.namespace, coordinate.localId].every(isTaskSegment))
-        throw new TypeError("task coordinate contains a noncanonical segment");
-    return identityCoordinate({ family: "task", segments: [...coordinate.namespace, coordinate.localId] });
+export function formatDebtId(coordinate) {
+    if (![...coordinate.namespace, coordinate.localId].every(isDebtSegment))
+        throw new TypeError("debt coordinate contains a noncanonical segment");
+    return identityCoordinate({ family: "debt", segments: [...coordinate.namespace, coordinate.localId] });
 }
-export function canonicalTaskId(value) {
-    const id = formatTaskId(parseTaskId(value));
+export function canonicalDebtId(value) {
+    const id = formatDebtId(parseDebtId(value));
     if (id !== value)
-        throw new TypeError("task ID is not canonical");
+        throw new TypeError("debt ID is not canonical");
     return id;
 }
-export const taskIdSchema = z.string().transform((value, context) => {
+export const debtIdSchema = z.string().transform((value, context) => {
     try {
-        return canonicalTaskId(value);
+        return canonicalDebtId(value);
     }
     catch {
-        context.addIssue({ code: "custom", message: "expected canonical TaskId" });
+        context.addIssue({ code: "custom", message: "expected canonical DebtId" });
         return z.NEVER;
     }
 });
-export const taskNamespaceSchema = z.array(z.string().refine(isTaskSegment)).readonly();
-export const taskIdsSchema = z
-    .array(taskIdSchema)
+export const debtNamespaceSchema = z.array(z.string().refine(isDebtSegment)).readonly();
+export const debtIdsSchema = z
+    .array(debtIdSchema)
     .superRefine((ids, context) => {
     if (new Set(ids).size !== ids.length)
-        context.addIssue({ code: "custom", message: "TaskIds must be unique" });
+        context.addIssue({ code: "custom", message: "DebtIds must be unique" });
 })
     .readonly();
 export function contractNamespace(id) {
     return ["kei", contractSegment(id)];
 }
-export function taskAuthorityPath(tasksDirectory, coordinate) {
-    if (![...coordinate.namespace, coordinate.localId].every(isTaskSegment))
-        throw new TypeError("task coordinate contains a noncanonical segment");
-    return join(tasksDirectory, ...coordinate.namespace.map((segment) => physicalTaskSegment(segment)), `${physicalTaskSegment(coordinate.localId)}.md`);
+export function debtAuthorityPath(debtsDirectory, coordinate) {
+    if (![...coordinate.namespace, coordinate.localId].every(isDebtSegment))
+        throw new TypeError("debt coordinate contains a noncanonical segment");
+    return join(debtsDirectory, ...coordinate.namespace.map((segment) => physicalDebtSegment(segment)), `${physicalDebtSegment(coordinate.localId)}.md`);
 }
 export function deriveLocalStem(title) {
     const stem = normalizeIdentityStem({ source: title });
     if (stem.length === 0)
-        throw new TypeError("task title must contain a normalized identity segment");
+        throw new TypeError("debt title must contain a normalized identity segment");
     const words = stem.split("-");
     let fitted = words[0];
     let count = [...fitted].length;
@@ -87,18 +87,18 @@ export function allocateLocalId(stem, occupied) {
     const seed = randomBytes(2).readUInt16BE(0);
     for (let offset = 0; offset <= 0xffff; offset += 1) {
         const suffix = ((seed + offset) & 0xffff).toString(16).padStart(4, "0");
-        const candidate = fitIdentityStem({ stem, maxBytes: TASK_LOCAL_ID_BYTES, suffix });
+        const candidate = fitIdentityStem({ stem, maxBytes: DEBT_LOCAL_ID_BYTES, suffix });
         if (!occupied.has(candidate))
             return candidate;
     }
-    throw new Error("task identity hexadecimal suffix space exhausted");
+    throw new Error("debt identity hexadecimal suffix space exhausted");
 }
-export function physicalTaskSegment(segment, maxBytes = TASK_LOCAL_ID_BYTES) {
+export function physicalDebtSegment(segment, maxBytes = DEBT_LOCAL_ID_BYTES) {
     if (Buffer.byteLength(segment) <= maxBytes && !WINDOWS_RESERVED.test(segment))
         return segment;
     if (Buffer.byteLength(segment) > maxBytes)
-        throw new TypeError("task identity cannot fit the physical filename budget");
-    throw new TypeError("task identity contains a Windows-reserved physical segment");
+        throw new TypeError("debt identity cannot fit the physical filename budget");
+    throw new TypeError("debt identity contains a Windows-reserved physical segment");
 }
 export function sameNamespace(left, right) {
     return left.length === right.length && left.every((segment, index) => segment === right[index]);

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

@@ -0,0 +1,111 @@
+import type { WorldRoot } from "../world.js";
+import type { NamespaceContextSource, ResolvedNamespaceContext } from "./context.js";
+import { type ExecutionContext } from "../akuma/requests.js";
+import { type DebtLifecycleVerb } from "./mutation.js";
+export type { WorldRoot } from "../world.js";
+import { type BlockedDebtRow, type DebtDetailFacts, type DebtDoctorIssue, type DebtRef, type DebtRow, type DebtTreeNode } from "./board.js";
+import { DebtAuthorityCorruptionError, type DebtPriority, type DebtState } from "./document.js";
+import type { DebtId } from "./identity.js";
+import { type AddDebtDocumentInput, type AddDebtInput, type DebtBatchResult, type DebtCleanupFailure, type DebtMutationResult, type DebtOutcome, type DebtRefusal, type DebtRetry, type DebtUpdateResult, type DebtView, type UpdateDebtInput } from "./operations.js";
+import { DEBT_RELATION_PREDICATE_FIELDS, type DebtPage, type DebtQueryExpression, type DebtQueryPredicate, type DebtQueryRow, type DebtQuerySort, type DebtRelationPredicateField } from "./query.js";
+export type DebtDetail = Omit<DebtDetailFacts, "debt"> & Readonly<{
+    debt: DebtView;
+}>;
+export type DebtList = DebtOutcome<DebtPage<DebtRow>>;
+export type BlockedDebtList = DebtOutcome<DebtPage<BlockedDebtRow>>;
+export type DebtQueryResult = DebtOutcome<DebtPage<DebtQueryRow>>;
+export type DebtContextSource = NamespaceContextSource;
+export type { ResolvedNamespaceContext };
+export type DebtContextResult = DebtOutcome<ResolvedNamespaceContext>;
+export type DebtDoctorReport = Readonly<{
+    issues: readonly DebtDoctorIssue[];
+}>;
+export type DebtDecompositionTree = DebtOutcome<DebtTreeNode>;
+export type { AddDebtDocumentInput, AddDebtInput, BlockedDebtRow, DebtBatchResult, DebtCleanupFailure, DebtDoctorIssue, DebtId, DebtMutationResult, DebtOutcome, DebtPriority, DebtRef, DebtRefusal, DebtRetry, DebtRow, DebtState, DebtTreeNode, DebtUpdateResult, DebtView, UpdateDebtInput, DebtPage, DebtQueryExpression, DebtQueryPredicate, DebtQueryRow, DebtQuerySort, DebtRelationPredicateField, };
+export type { LibraryExecution } from "../akuma/requests.js";
+export { DebtAuthorityCorruptionError, DEBT_RELATION_PREDICATE_FIELDS };
+export { observeRecentDebtStatus, type RecentDebtStatusRow } from "./catalog.js";
+export { boundedListLimit as debtRowViewLimit } from "../bounded-list.js";
+/**
+ * The one bound operation table for a captured route. Each entry either calls the
+ * local Debt operations directly or sends the same validated values as the one
+ * forwarded request shape. Validation stays in the handle methods.
+ */
+type DebtOperations = Readonly<{
+    add(values: AddDebtInput): Promise<DebtMutationResult>;
+    addDocument(values: AddDebtDocumentInput): Promise<DebtMutationResult>;
+    update(id: DebtId, values: UpdateDebtInput): Promise<DebtUpdateResult>;
+    lifecycle(id: DebtId, verb: DebtLifecycleVerb, note: string | undefined, signal?: AbortSignal): Promise<DebtMutationResult>;
+    batch(verb: DebtLifecycleVerb, ids: readonly DebtId[], note: string | undefined, signal?: AbortSignal): Promise<DebtBatchResult>;
+}>;
+declare class DebtHandle {
+    readonly id: DebtId;
+    private readonly world;
+    private readonly operations;
+    constructor(id: DebtId, world: WorldRoot, operations: DebtOperations);
+    read(): Promise<DebtDetail | null>;
+    tree(): Promise<DebtDecompositionTree>;
+    update(input: UpdateDebtInput): Promise<DebtUpdateResult>;
+    private lifecycle;
+    done(input?: {
+        note?: string;
+        signal?: AbortSignal;
+    }): Promise<DebtMutationResult>;
+    drop(input?: {
+        note?: string;
+        signal?: AbortSignal;
+    }): Promise<DebtMutationResult>;
+}
+export type Debt = DebtHandle;
+declare class DebtsHandle {
+    private readonly world;
+    readonly root: WorldRoot;
+    private readonly operations;
+    constructor(world: WorldRoot, execution: ExecutionContext);
+    debt(input: Readonly<{
+        id: string;
+    }>): Debt;
+    add(input: AddDebtInput): Promise<DebtMutationResult>;
+    addDocument(input: AddDebtDocumentInput): Promise<DebtMutationResult>;
+    list(input?: Readonly<{
+        selection?: "active" | "closed" | "all";
+        scope?: "namespace" | "world";
+        namespace?: readonly string[];
+        limit?: number;
+    }>): Promise<DebtList>;
+    ready(input?: Readonly<{
+        scope?: "namespace" | "world";
+        namespace?: readonly string[];
+        parent?: string;
+        limit?: number;
+    }>): Promise<DebtList>;
+    blocked(input?: Readonly<{
+        scope?: "namespace" | "world";
+        namespace?: readonly string[];
+        parent?: string;
+        limit?: number;
+    }>): Promise<BlockedDebtList>;
+    query(input?: Readonly<{
+        where?: DebtQueryExpression;
+        scope?: "namespace" | "world";
+        namespace?: readonly string[];
+        sort?: DebtQuerySort;
+        limit?: number;
+    }>): Promise<DebtQueryResult>;
+    doctor(): Promise<DebtDoctorReport>;
+    batch(input: Readonly<{
+        verb: "done" | "drop";
+        ids: readonly string[];
+        note?: string;
+        signal?: AbortSignal;
+    }>): Promise<DebtBatchResult>;
+}
+export type Debts = DebtsHandle;
+/**
+ * The one Debts composition. Public `of` fixes local execution; CLI and Body pass their captured
+ * internal channel through `debtsWithExecution` instead of a second constructor.
+ */
+export declare function debtsWithExecution(world: WorldRoot, execution: ExecutionContext): Debts;
+export declare const Debts: Readonly<{
+    of(world: WorldRoot): Debts;
+}>;