@astrosheep/keiyaku 4.5.7 → 4.5.8

package/build/src/task/mutation.js

@@ -1,4 +1,12 @@
-import { addInput, closed, namespace, record, taskId, taskIds, text, updateInput } from "./input.js";
+/* eslint-disable max-lines -- Task owns one coherent forwarded mutation boundary. */
+import { World } from "../world.js";
+import { requestBodyCommand } from "../akuma/request-rendezvous.js";
+import { eraseRequestCommand } from "../akuma/request-wire.js";
+import { addTask, addTaskDocument, batchTasks, lifecycleTask, updateTask, } from "./operations.js";
+import { composeTasks } from "./compose.js";
+import { isTaskSegment } from "./identity.js";
+import { taskBatchResultSchema, taskCompositionResultSchema, taskMutationIdSchema, taskMutationResultSchema, taskUpdateResultSchema, isTaskMutationExecutionResult, } from "./mutation-result.js";
+import { z } from "zod";
 export const TASK_MUTATION_ACTIONS = Object.freeze([
     "task.add",
     "task.addDocument",
@@ -15,121 +23,320 @@ const TASK_MUTATION_ACTION_SET = new Set(TASK_MUTATION_ACTIONS);
 export function isTaskMutationAction(value) {
     return typeof value === "string" && TASK_MUTATION_ACTION_SET.has(value);
 }
-function mutationObject(value, keys, label) {
-    const decoded = record(value, label);
-    closed(decoded, keys, label);
-    return decoded;
+const nonblankTextSchema = z.string().refine((value) => value.trim() !== "");
+const namespaceSchema = z.array(z.string().refine(isTaskSegment)).readonly();
+const taskIdsBaseSchema = z.array(taskMutationIdSchema).superRefine((ids, context) => {
+    if (new Set(ids).size !== ids.length)
+        context.addIssue({ code: "custom", message: "TaskIds must be unique" });
+});
+const taskIdsSchema = taskIdsBaseSchema.readonly();
+const nonemptyTaskIdsSchema = taskIdsBaseSchema.min(1).readonly();
+const taskStateSchema = z.enum(["open", "in_progress", "on_hold", "done", "drop"]);
+const taskPrioritySchema = z.union([z.literal(0), z.literal(1), z.literal(2), z.literal(3)]);
+const addInputSchema = z
+    .object({
+    title: nonblankTextSchema,
+    namespace: namespaceSchema,
+    body: z.string().optional(),
+    note: z.string().optional(),
+    state: taskStateSchema.optional(),
+    priority: taskPrioritySchema.optional(),
+    needs: taskIdsSchema.optional(),
+    parent: taskMutationIdSchema.nullable().optional(),
+    supersedes: taskIdsSchema.optional(),
+    relates: taskIdsSchema.optional(),
+})
+    .strict();
+const updateInputSchema = z
+    .object({
+    title: nonblankTextSchema.optional(),
+    body: z.string().optional(),
+    appendBody: z.string().optional(),
+    note: z.string().optional(),
+    priority: taskPrioritySchema.optional(),
+    needs: taskIdsSchema.optional(),
+    addNeeds: taskIdsSchema.optional(),
+    dropNeeds: taskIdsSchema.optional(),
+    parent: taskMutationIdSchema.nullable().optional(),
+    supersedes: taskIdsSchema.optional(),
+    addSupersedes: taskIdsSchema.optional(),
+    dropSupersedes: taskIdsSchema.optional(),
+    relates: taskIdsSchema.optional(),
+    addRelates: taskIdsSchema.optional(),
+    dropRelates: taskIdsSchema.optional(),
+})
+    .strict()
+    .superRefine((input, context) => {
+    if (input.body !== undefined && input.appendBody !== undefined)
+        context.addIssue({ code: "custom", message: "body and appendBody are mutually exclusive" });
+    if (Object.values(input).every((value) => value === undefined))
+        context.addIssue({ code: "custom", message: "update requires at least one field change" });
+});
+const addRequestSchema = z
+    .object({ input: addInputSchema })
+    .strict()
+    .transform(({ input }) => ({ action: "task.add", input }));
+const addDocumentRequestSchema = z
+    .object({ input: z.object({ markdown: z.string(), namespace: namespaceSchema }).strict() })
+    .strict()
+    .transform(({ input }) => ({ action: "task.addDocument", input }));
+const composeRequestSchema = z
+    .object({ markdown: z.string(), namespace: namespaceSchema })
+    .strict()
+    .transform((request) => ({ action: "task.compose", ...request }));
+const updateRequestSchema = z
+    .object({ id: taskMutationIdSchema, input: updateInputSchema })
+    .strict()
+    .transform((request) => ({ action: "task.update", ...request }));
+const singleOrBatchRequestSchema = (action) => z.union([
+    z
+        .object({ id: taskMutationIdSchema })
+        .strict()
+        .transform(({ id }) => ({ action, id })),
+    z
+        .object({ ids: nonemptyTaskIdsSchema })
+        .strict()
+        .transform(({ ids }) => ({ action, ids })),
+]);
+const singleRequestSchema = (action) => z
+    .object({ id: taskMutationIdSchema })
+    .strict()
+    .transform((request) => ({ action, ...request }));
+const terminalRequestSchema = (action) => z.union([
+    z
+        .object({ id: taskMutationIdSchema, note: z.string().optional() })
+        .strict()
+        .transform(({ id, note }) => ({ action, id, ...(note === undefined ? {} : { note }) })),
+    z
+        .object({ ids: nonemptyTaskIdsSchema, note: z.string().optional() })
+        .strict()
+        .transform(({ ids, note }) => ({ action, ids, ...(note === undefined ? {} : { note }) })),
+]);
+const taskRequestSchemas = {
+    "task.add": addRequestSchema,
+    "task.addDocument": addDocumentRequestSchema,
+    "task.compose": composeRequestSchema,
+    "task.done": terminalRequestSchema("task.done"),
+    "task.drop": terminalRequestSchema("task.drop"),
+    "task.hold": singleOrBatchRequestSchema("task.hold"),
+    "task.resume": singleRequestSchema("task.resume"),
+    "task.start": singleOrBatchRequestSchema("task.start"),
+    "task.stop": singleRequestSchema("task.stop"),
+    "task.update": updateRequestSchema,
+};
+const worldPathSchema = z.string().min(1);
+const taskBodyRequestSchemas = {
+    "task.add": z.object({ world: worldPathSchema, request: taskRequestSchemas["task.add"] }).strict(),
+    "task.addDocument": z.object({ world: worldPathSchema, request: taskRequestSchemas["task.addDocument"] }).strict(),
+    "task.compose": z.object({ world: worldPathSchema, request: taskRequestSchemas["task.compose"] }).strict(),
+    "task.done": z.object({ world: worldPathSchema, request: taskRequestSchemas["task.done"] }).strict(),
+    "task.drop": z.object({ world: worldPathSchema, request: taskRequestSchemas["task.drop"] }).strict(),
+    "task.hold": z.object({ world: worldPathSchema, request: taskRequestSchemas["task.hold"] }).strict(),
+    "task.resume": z.object({ world: worldPathSchema, request: taskRequestSchemas["task.resume"] }).strict(),
+    "task.start": z.object({ world: worldPathSchema, request: taskRequestSchemas["task.start"] }).strict(),
+    "task.stop": z.object({ world: worldPathSchema, request: taskRequestSchemas["task.stop"] }).strict(),
+    "task.update": z.object({ world: worldPathSchema, request: taskRequestSchemas["task.update"] }).strict(),
+};
+export const taskMutationServiceSchema = z.object({ action: z.enum(TASK_MUTATION_ACTIONS) }).strict();
+export const forwardedTaskReferenceSchema = z
+    .object({ kind: z.literal("served-reference"), action: z.enum(TASK_MUTATION_ACTIONS) })
+    .strict();
+function decodeTaskMutationExecutionContext(value) {
+    const context = resultRecord(value);
+    if (context === null ||
+        typeof context.requester !== "string" ||
+        context.requester.trim() === "" ||
+        !isAbortSignal(context.signal) ||
+        !isTaskMutationRequestPort(context.upstream))
+        throw new Error("invalid Task execution context");
+    return { requester: context.requester, signal: context.signal, upstream: context.upstream };
 }
-export function decodeTaskMutationRequest(action, value) {
-    switch (action) {
-        case "task.add": {
-            const input = mutationObject(value, ["input"], "task.add request");
-            const raw = mutationObject(input.input, ["title", "namespace", "body", "note", "state", "priority", "needs", "parent", "supersedes", "relates"], "task.add input");
-            const decoded = addInput(raw);
-            if (decoded.namespace === undefined)
-                throw new TypeError("task.add request namespace is required");
-            return { action, input: { ...decoded, namespace: decoded.namespace } };
-        }
-        case "task.addDocument": {
-            const input = mutationObject(value, ["input"], "task.addDocument request");
-            const raw = mutationObject(input.input, ["markdown", "namespace"], "task.addDocument input");
-            const markdown = text(raw.markdown, "markdown");
-            if (markdown === undefined)
-                throw new TypeError("markdown is required");
-            const selected = namespace(raw.namespace);
-            if (selected === undefined)
-                throw new TypeError("task.addDocument request namespace is required");
-            return { action, input: { markdown, namespace: selected } };
-        }
-        case "task.compose": {
-            const input = mutationObject(value, ["markdown", "namespace"], "task.compose request");
-            const markdown = text(input.markdown, "markdown");
-            if (markdown === undefined)
-                throw new TypeError("markdown is required");
-            const selected = namespace(input.namespace);
-            if (selected === undefined)
-                throw new TypeError("task.compose request namespace is required");
-            return { action, markdown, namespace: selected };
-        }
-        case "task.update": {
-            const request = mutationObject(value, ["id", "input"], "task.update request");
-            const raw = mutationObject(request.input, [
-                "title",
-                "body",
-                "appendBody",
-                "note",
-                "priority",
-                "needs",
-                "addNeeds",
-                "dropNeeds",
-                "parent",
-                "supersedes",
-                "addSupersedes",
-                "dropSupersedes",
-                "relates",
-                "addRelates",
-                "dropRelates",
-            ], "task.update input");
-            return { action, id: taskId(request.id), input: updateInput(raw) };
-        }
-        case "task.start":
-        case "task.stop":
-        case "task.resume": {
-            const request = mutationObject(value, ["id"], `${action} request`);
-            return { action, id: taskId(request.id) };
-        }
-        case "task.hold": {
-            const request = mutationObject(value, ["ids"], "task.hold request");
-            return { action, ids: taskIds(request.ids, "ids") ?? [] };
-        }
-        case "task.done":
-        case "task.drop": {
-            const request = mutationObject(value, ["ids", "note"], `${action} request`);
-            const note = text(request.note, "note");
-            return { action, ids: taskIds(request.ids, "ids") ?? [], ...(note === undefined ? {} : { note }) };
-        }
+function isAbortSignal(value) {
+    return (value !== null &&
+        typeof value === "object" &&
+        typeof value.throwIfAborted === "function");
+}
+function isTaskMutationRequestPort(value) {
+    const port = resultRecord(value);
+    return port !== null && typeof port.task === "function";
+}
+function resultRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function decodeTaskBodyRequest(action, value) {
+    const parsed = taskBodyRequestSchemas[action].safeParse(value);
+    return parsed.success ? parsed.data : null;
+}
+function decodeTaskService(action, value) {
+    const parsed = taskMutationServiceSchema.safeParse(value);
+    if (!parsed.success || parsed.data.action !== action)
+        throw new Error(`malformed stored Task service evidence for ${action}`);
+    return parsed.data;
+}
+function decodeTaskReference(action, value) {
+    const parsed = forwardedTaskReferenceSchema.safeParse(value);
+    if (!parsed.success || parsed.data.action !== action)
+        throw new Error(`malformed Task service reference for ${action}`);
+    return parsed.data;
+}
+/** Task owns forwarded mutation payload, live result, and durable service evidence. */
+export function taskMutationRequestCommand(action) {
+    return {
+        action,
+        encodeRequest: (input) => {
+            const { action: _action, ...request } = input.request;
+            return { world: input.world, request };
+        },
+        decodeRequest: (value) => decodeTaskBodyRequest(action, value),
+        encodeResult: (result) => result,
+        decodeResult: (result) => {
+            if (!isTaskMutationExecutionResult(result)) {
+                throw new Error(`transport integrity: Task ${action} returned an invalid live result`);
+            }
+            return result;
+        },
+        encodeService: (service) => decodeTaskService(action, service),
+        decodeService: (service) => decodeTaskService(action, service),
+        projectService: (service) => decodeTaskReference(action, { kind: "served-reference", action: service.action }),
+        decodeReference: (reference) => decodeTaskReference(action, reference),
+        isPermitted: (allowed) => allowed.includes(action),
+        decodeExecutionContext: decodeTaskMutationExecutionContext,
+        execute: async (request, context) => {
+            const world = await World.prove(request.world);
+            return {
+                result: await context.upstream.task({
+                    world,
+                    request: request.request,
+                    requester: context.requester,
+                    signal: context.signal,
+                }),
+                service: { action: request.request.action },
+            };
+        },
+    };
+}
+export function taskMutationRequestCommands() {
+    return {
+        "task.add": eraseRequestCommand(taskMutationRequestCommand("task.add")),
+        "task.addDocument": eraseRequestCommand(taskMutationRequestCommand("task.addDocument")),
+        "task.compose": eraseRequestCommand(taskMutationRequestCommand("task.compose")),
+        "task.done": eraseRequestCommand(taskMutationRequestCommand("task.done")),
+        "task.drop": eraseRequestCommand(taskMutationRequestCommand("task.drop")),
+        "task.hold": eraseRequestCommand(taskMutationRequestCommand("task.hold")),
+        "task.resume": eraseRequestCommand(taskMutationRequestCommand("task.resume")),
+        "task.start": eraseRequestCommand(taskMutationRequestCommand("task.start")),
+        "task.stop": eraseRequestCommand(taskMutationRequestCommand("task.stop")),
+        "task.update": eraseRequestCommand(taskMutationRequestCommand("task.update")),
+    };
+}
+function taskResultForRequest(request, value) {
+    const schema = request.action === "task.compose"
+        ? taskCompositionResultSchema
+        : request.action === "task.update"
+            ? taskUpdateResultSchema
+            : "ids" in request
+                ? taskBatchResultSchema
+                : taskMutationResultSchema;
+    return schema.safeParse(value).success;
+}
+export async function requestForwardedTask(input) {
+    const response = await requestBodyCommand({
+        directory: input.directory,
+        ...(input.id === undefined ? {} : { id: input.id }),
+        command: taskMutationRequestCommand(input.request.action),
+        value: { world: input.world, request: input.request },
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+    });
+    if (response.kind === "reference")
+        return response.reference;
+    if (!taskResultForRequest(input.request, response.result)) {
+        throw new Error(`transport integrity: request Task ${input.request.action} returned an invalid live result`);
     }
+    return response.result;
+}
+export function decodeTaskMutationRequest(action, value) {
+    const parsed = taskRequestSchemas[action].safeParse(value);
+    if (!parsed.success)
+        throw new TypeError(`invalid ${action} request`);
+    return parsed.data;
+}
+function addTaskOptions(input, actor, signal) {
+    const { body, note, state, priority, needs, parent, supersedes, relates, ...required } = input;
+    return {
+        ...required,
+        actor,
+        ...(body === undefined ? {} : { body }),
+        ...(note === undefined ? {} : { note }),
+        ...(state === undefined ? {} : { state }),
+        ...(priority === undefined ? {} : { priority }),
+        ...(needs === undefined ? {} : { needs }),
+        ...(parent === undefined ? {} : { parent }),
+        ...(supersedes === undefined ? {} : { supersedes }),
+        ...(relates === undefined ? {} : { relates }),
+        ...(signal === undefined ? {} : { signal }),
+    };
+}
+function updateTaskOptions(input, signal) {
+    const { title, body, appendBody, note, priority, needs, addNeeds, dropNeeds, parent, supersedes, addSupersedes, dropSupersedes, relates, addRelates, dropRelates, } = input;
+    return {
+        ...(title === undefined ? {} : { title }),
+        ...(body === undefined ? {} : { body }),
+        ...(appendBody === undefined ? {} : { appendBody }),
+        ...(note === undefined ? {} : { note }),
+        ...(priority === undefined ? {} : { priority }),
+        ...(needs === undefined ? {} : { needs }),
+        ...(addNeeds === undefined ? {} : { addNeeds }),
+        ...(dropNeeds === undefined ? {} : { dropNeeds }),
+        ...(parent === undefined ? {} : { parent }),
+        ...(supersedes === undefined ? {} : { supersedes }),
+        ...(addSupersedes === undefined ? {} : { addSupersedes }),
+        ...(dropSupersedes === undefined ? {} : { dropSupersedes }),
+        ...(relates === undefined ? {} : { relates }),
+        ...(addRelates === undefined ? {} : { addRelates }),
+        ...(dropRelates === undefined ? {} : { dropRelates }),
+        ...(signal === undefined ? {} : { signal }),
+    };
 }
 export async function executeTaskMutation(input) {
-    const { Tasks } = await import("./index.js");
-    const tasks = Tasks.of(input.world);
-    const { request, signal } = input;
+    const { world, request, signal } = input;
     const withSignal = signal === undefined ? {} : { signal };
     switch (request.action) {
         case "task.add":
-            return await tasks.add({ ...request.input, actor: input.requester, ...withSignal });
+            return await addTask(world, addTaskOptions(request.input, input.requester, signal));
         case "task.addDocument":
-            return await tasks.addDocument({ ...request.input, actor: input.requester, ...withSignal });
+            return await addTaskDocument(world, { ...request.input, actor: input.requester, ...withSignal });
         case "task.compose":
-            return await tasks.compose({
+            return await composeTasks({
+                world,
                 markdown: request.markdown,
-                namespace: request.namespace,
+                defaultNamespace: request.namespace,
                 actor: input.requester,
+                planOnly: false,
                 ...withSignal,
             });
         case "task.update":
-            return await tasks.task({ id: request.id }).update({ ...request.input, ...withSignal });
+            return await updateTask(world, request.id, updateTaskOptions(request.input, signal));
         case "task.start":
-            return await tasks.task({ id: request.id }).start(withSignal);
+            if ("ids" in request)
+                return await batchTasks(world, "start", request.ids, signal);
+            return await lifecycleTask(world, request.id, "start", signal);
         case "task.stop":
-            return await tasks.task({ id: request.id }).stop(withSignal);
+            return await lifecycleTask(world, request.id, "stop", signal);
         case "task.resume":
-            return await tasks.task({ id: request.id }).resume(withSignal);
+            return await lifecycleTask(world, request.id, "resume", signal);
         case "task.hold":
-            return await tasks.batch({ verb: "hold", ids: request.ids, ...withSignal });
+            if ("ids" in request)
+                return await batchTasks(world, "hold", request.ids, signal);
+            return await lifecycleTask(world, request.id, "hold", signal);
         case "task.done":
-            return await tasks.batch({
-                verb: "done",
-                ids: request.ids,
-                ...withSignal,
-                ...(request.note === undefined ? {} : { note: request.note }),
-            });
+            if ("ids" in request)
+                return await batchTasks(world, "done", request.ids, signal, request.note);
+            return await lifecycleTask(world, request.id, "done", signal, request.note);
         case "task.drop":
-            return await tasks.batch({
-                verb: "drop",
-                ids: request.ids,
-                ...withSignal,
-                ...(request.note === undefined ? {} : { note: request.note }),
-            });
+            if ("ids" in request)
+                return await batchTasks(world, "drop", request.ids, signal, request.note);
+            return await lifecycleTask(world, request.id, "drop", signal, request.note);
     }
 }

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

@@ -119,7 +119,7 @@ export declare function addTask(world: WorldRoot, input: AddTaskInput): Promise<
 export declare function addTaskDocument(world: WorldRoot, input: AddTaskDocumentInput): Promise<TaskMutationResult>;
 export declare function updateTask(world: WorldRoot, id: TaskId, input: UpdateTaskInput): Promise<TaskUpdateResult>;
 export declare function lifecycleTask(world: WorldRoot, id: TaskId, verb: TaskLifecycleVerb, signal?: AbortSignal, note?: string): Promise<TaskMutationResult>;
-export declare function batchTasks(world: WorldRoot, verb: "done" | "drop" | "hold", ids: readonly TaskId[], signal?: AbortSignal, note?: string): Promise<TaskBatchResult>;
+export declare function batchTasks(world: WorldRoot, verb: "start" | "done" | "drop" | "hold", ids: readonly TaskId[], signal?: AbortSignal, note?: string): Promise<TaskBatchResult>;
 export declare function settleTask(world: WorldRoot, id: TaskId): Promise<SettledTaskResult>;
 export declare function listTasks(world: WorldRoot, namespace: readonly string[] | undefined, selection: "active" | "closed" | "all", scope?: "namespace" | "world", limit?: number): Promise<TaskOutcome<TaskPage<TaskRow>>>;
 export declare function readTaskDetails(world: WorldRoot, ids: readonly TaskId[]): Promise<TaskOutcome<readonly TaskDetailFacts[]>>;
@@ -136,7 +136,4 @@ export declare function queryTasks(input: Readonly<{
     sort?: TaskQuerySort;
     limit?: number;
 }>): Promise<TaskOutcome<TaskPage<TaskQueryRow>>>;
-/** Internal composite observation from one complete Task board read. */
 export declare function observeTaskBoard(world: WorldRoot): Promise<TaskBoardObservation>;
-/** Internal identity catalog from one complete Task board read. */
-export declare function observeTaskCatalogRows(world: WorldRoot): Promise<readonly TaskRow[]>;

package/build/src/task/operations.js

@@ -304,12 +304,6 @@ export async function queryTasks(input) {
         }),
     };
 }
-/** Internal composite observation from one complete Task board read. */
 export async function observeTaskBoard(world) {
     return projectTaskBoardObservation((await readBoard(world)).board);
 }
-/** Internal identity catalog from one complete Task board read. */
-export async function observeTaskCatalogRows(world) {
-    const board = (await readBoard(world)).board;
-    return projectRows(board, createTaskRelations(board), null, "all");
-}

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

@@ -0,0 +1,2 @@
+export { TASK_RELATION_PREDICATE_FIELDS, TaskAuthorityCorruptionError, Tasks } from "./index.js";
+export type * from "./index.js";

package/build/src/task/public.js

@@ -0,0 +1 @@
+export { TASK_RELATION_PREDICATE_FIELDS, TaskAuthorityCorruptionError, Tasks } from "./index.js";

package/build/src/workspace-place.d.ts

@@ -1,6 +1,7 @@
 import { type ContractId } from "./core/facts/types.js";
 import type { GitRepository } from "./git/process.js";
 export declare const CONTRACT_PLACES: readonly string[];
+declare const placeAuthorityFence: unique symbol;
 export type Place = string & {
     readonly [placeBrand]: "Place";
 };
@@ -24,6 +25,9 @@ export type ManagedWorktreeAppointment = Readonly<{
     kind: "failed";
     diagnostic: string;
 }>;
+export type PlaceAuthorityFence = Readonly<{
+    readonly [placeAuthorityFence]: true;
+}>;
 export declare function placeRegisterPath(repository: GitRepository): string;
 export declare function place(value: string): Place;
 export declare function nextPlace(current?: Place): Place;
@@ -32,9 +36,10 @@ export declare function decodePlaceRegister(path: string, bytes: string): PlaceR
 export declare function emptyPlaceRegister(): PlaceRegister;
 export declare function readPlaceRegister(repository: GitRepository): Promise<PlaceRegister>;
 export declare function appointmentFor(register: PlaceRegister, contract: ContractId): PlaceAppointment | undefined;
+export declare function withPlaceAuthorityFence<T>(repository: GitRepository, action: (fence: PlaceAuthorityFence) => T | Promise<T>): Promise<T>;
 export declare function appointManagedWorktrees(repository: GitRepository, contracts: readonly ContractId[]): Promise<PlaceRegister>;
-export declare function releaseManagedWorktrees(repository: GitRepository, contracts: readonly ContractId[]): Promise<void>;
+export declare function releaseManagedWorktrees(repository: GitRepository, contracts: readonly ContractId[], fence?: PlaceAuthorityFence): Promise<void>;
 /** Remove only an already-empty Place authority. */
-export declare function nukeEmptyPlaceAuthority(repository: GitRepository): Promise<void>;
+export declare function nukeEmptyPlaceAuthority(repository: GitRepository, fence?: PlaceAuthorityFence): Promise<void>;
 export declare function readManagedWorktreeAppointment(repository: GitRepository, contract: ContractId, register?: PlaceRegister): Promise<ManagedWorktreeAppointment>;
 export {};

package/build/src/workspace-place.js

@@ -184,6 +184,7 @@ export const CONTRACT_PLACES = Object.freeze([
 const PLACE_INDEX = new Map(CONTRACT_PLACES.map((base, index) => [base, index]));
 const PLACE_VERSION = 1;
 const GENERATION_SUFFIX = /^(?:[2-9]|[1-9][0-9]+)$/u;
+const placeAuthorityFence = Symbol("place-authority-fence");
 function placePaths(repository) {
     return {
         authority: join(repository.commonDirectory, "keiyaku", "places.json"),
@@ -305,29 +306,38 @@ export async function readPlaceRegister(repository) {
 export function appointmentFor(register, contract) {
     return register.byContract.get(contract);
 }
-async function mutatePlaceRegister(repository, mutate) {
+export async function withPlaceAuthorityFence(repository, action) {
     const location = placePaths(repository);
     const held = await acquireSqliteTransactionLock({ path: location.lock, mode: "immediate" });
     try {
-        const current = await readPlaceRegister(repository);
-        const next = mutate(current);
-        const bytes = canonicalPlaceRegister(next);
-        try {
-            if ((await readFile(location.authority, "utf8")) === bytes)
-                return next;
-        }
-        catch (error) {
-            if (error.code !== "ENOENT")
-                throw error;
-        }
-        await mkdir(dirname(location.authority), { recursive: true });
-        await replaceFileDurably(location.authority, bytes);
-        return next;
+        return await action({ [placeAuthorityFence]: true });
     }
     finally {
         held.close();
     }
 }
+async function mutatePlaceRegisterInFence(repository, mutate) {
+    const location = placePaths(repository);
+    const current = await readPlaceRegister(repository);
+    const next = mutate(current);
+    const bytes = canonicalPlaceRegister(next);
+    try {
+        if ((await readFile(location.authority, "utf8")) === bytes)
+            return next;
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    await mkdir(dirname(location.authority), { recursive: true });
+    await replaceFileDurably(location.authority, bytes);
+    return next;
+}
+async function mutatePlaceRegister(repository, mutate, fence) {
+    if (fence !== undefined)
+        return await mutatePlaceRegisterInFence(repository, mutate);
+    return await withPlaceAuthorityFence(repository, async () => await mutatePlaceRegisterInFence(repository, mutate));
+}
 function withAppointments(register, contracts) {
     const additions = [];
     const occupied = new Set(register.byPlace.keys());
@@ -360,14 +370,14 @@ function firstUnoccupiedPlace(contract, occupied) {
 export async function appointManagedWorktrees(repository, contracts) {
     return await mutatePlaceRegister(repository, (current) => withAppointments(current, contracts));
 }
-export async function releaseManagedWorktrees(repository, contracts) {
+export async function releaseManagedWorktrees(repository, contracts, fence) {
     if (contracts.length === 0)
         return;
     const drop = new Set(contracts);
     await mutatePlaceRegister(repository, (current) => {
         const kept = current.appointments.filter((appointment) => !drop.has(appointment.contract));
         return kept.length === current.appointments.length ? current : indexedRegister(kept);
-    });
+    }, fence);
 }
 async function regularFile(path) {
     const value = await lstat(path).catch((error) => error.code === "ENOENT" ? undefined : Promise.reject(error));
@@ -378,22 +388,22 @@ async function regularFile(path) {
     return true;
 }
 /** Remove only an already-empty Place authority. */
-export async function nukeEmptyPlaceAuthority(repository) {
+export async function nukeEmptyPlaceAuthority(repository, fence) {
     const location = placePaths(repository);
     const [authorityPresent, lockPresent] = [await regularFile(location.authority), await regularFile(location.lock)];
     if (!authorityPresent && !lockPresent)
         return;
-    const held = await acquireSqliteTransactionLock({ path: location.lock, mode: "immediate" });
-    try {
+    const nuke = async () => {
         const current = await readPlaceRegister(repository);
         if (current.appointments.length !== 0)
             throw new Error("Place authority still has managed worktree appointments");
         if (await regularFile(location.authority))
             await unlink(location.authority);
-    }
-    finally {
-        held.close();
-    }
+    };
+    if (fence !== undefined)
+        await nuke();
+    else
+        await withPlaceAuthorityFence(repository, nuke);
 }
 export async function readManagedWorktreeAppointment(repository, contract, register) {
     try {

package/build/src/world.d.ts

@@ -22,5 +22,6 @@ export declare const World: Readonly<{
     resolve(input: WorldInput): Promise<WorldResolution>;
     locate(input: WorldInput): Promise<WorldRoot | null>;
     at(input: string): Promise<WorldRoot>;
+    prove(input: string): Promise<WorldRoot>;
 }>;
 export {};

package/build/src/world.js

@@ -113,6 +113,14 @@ async function exact(input) {
     await ensureMarker(root);
     return brand(root);
 }
+async function proved(input) {
+    const resolution = await resolved({ cwd: input, repositoryRoot: input });
+    const root = resolution.root;
+    if (root === null || input !== root) {
+        throw new WorldError("invalid-world", "world path must be its canonical physical directory coordinate");
+    }
+    return root;
+}
 async function resolved(input) {
     const values = await inputValues(input, "world location");
     const root = values.repositoryRoot === undefined ? await locateMarker(values.cwd) : brand(values.repositoryRoot);
@@ -147,4 +155,7 @@ export const World = Object.freeze({
     at(input) {
         return exact(input);
     },
+    prove(input) {
+        return proved(input);
+    },
 });