@astrosheep/keiyaku 4.5.11 → 4.5.13

package/build/src/library/fleet.js

@@ -1,47 +1,27 @@
-/* eslint-disable max-lines -- Fleet owns one coherent public operation surface. */
-import { Akuma, AkumaNotBornError, akumaIdSchema, defaultWaitComplete, } from "../akuma/index.js";
-import { readBudgetedStatus, tellAkumaWithId } from "../akuma/akuma.js";
-import { executionChannel, localExecutionContext, requestBodyCommand, } from "../akuma/requests.js";
-import { eraseRequestCommand } from "../akuma/request-wire.js";
-import { readDispatch } from "../dispatch/index.js";
-import { observeTaskBoard } from "../task/operations.js";
+/** @architectureCompositionRoot */
+import { Akuma, AkumaNotBornError, } from "../akuma/index.js";
+import { readBudgetedStatus } from "../akuma/akuma.js";
+import { executionChannel, localExecutionContext } from "../akuma/requests.js";
+import { requestForwardedFleetKill, requestForwardedFleetTell, requestForwardedFleetWait, } from "../akuma/fleet-request.js";
+import { executeKillAkuma, executeTellAkuma, executeWaitAkuma } from "../akuma/fleet-execution.js";
+import { observeDispatchAssociation } from "../dispatch/index.js";
+import { observeCreatedTaskObservations } from "../task/created-observation.js";
 import { addressAkuma, addressAkumaSet } from "./address.js";
 import { requireInput } from "./input.js";
-import { isKillResult, isTellResult, isWaitResult, fleetResultSchemas, parseAkumaObservation, parseCreatedTaskObservation, } from "./fleet-result.js";
+import { fleetResultSchemas, parseAkumaObservation, } from "../akuma/fleet-observation.js";
 import { scopeForRepo } from "./repo.js";
 import { parsePublicHistoryId } from "../akuma/identity.js";
-import { z } from "zod";
 function source(path) {
     return Akuma.of(path);
 }
 function observationDiagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
-const NO_DISPATCH = { kind: "none" };
 async function dispatchAssociation(repo, id) {
-    if (repo === undefined)
-        return NO_DISPATCH;
-    try {
-        const dispatch = await readDispatch(scopeForRepo(repo), id);
-        return dispatch === null ? NO_DISPATCH : { kind: "associated", contractId: dispatch.contractId };
-    }
-    catch (error) {
-        return { kind: "failed", diagnostic: observationDiagnostic(error) };
-    }
-}
-function createdTaskDiagnostic(error) {
-    return observationDiagnostic(error);
+    return await observeDispatchAssociation(repo === undefined ? undefined : scopeForRepo(repo), id);
 }
 async function createdTasksFor(path, statuses) {
-    let board;
-    try {
-        board = await observeTaskBoard(path);
-    }
-    catch (error) {
-        const failed = { kind: "failed", diagnostic: createdTaskDiagnostic(error) };
-        return statuses.map(() => failed);
-    }
-    return statuses.map((status) => parseCreatedTaskObservation({ kind: "present", rows: board.selectCreatedBy(status.id) }));
+    return await observeCreatedTaskObservations(path, statuses.map((status) => status.id));
 }
 async function observeAkuma(status, path, repo) {
     return (await observeAkumaSet([status], path, repo))[0];
@@ -76,269 +56,15 @@ function timeout(value) {
     }
     return value;
 }
-function delay(milliseconds, signal) {
-    return new Promise((resolve, reject) => {
-        let timer;
-        const done = () => {
-            signal?.removeEventListener("abort", abort);
-            resolve();
-        };
-        const abort = () => {
-            clearTimeout(timer);
-            signal?.removeEventListener("abort", abort);
-            reject(signal?.reason ?? new Error("upstream request aborted"));
-        };
-        timer = setTimeout(done, milliseconds);
-        if (signal?.aborted)
-            abort();
-        else
-            signal?.addEventListener("abort", abort, { once: true });
-    });
-}
-const SHARED_ORDINARY_BUDGET = 30;
-const POLL_MS = 100;
-async function observeWaitRound(path, ids, signal) {
-    signal?.throwIfAborted();
-    if (ids.length <= 1) {
-        return {
-            statuses: await Promise.all(ids.map(async (id) => await source(path).of({ id }).status())),
-            unobserved: [],
-        };
-    }
-    let remaining = SHARED_ORDINARY_BUDGET;
-    const statuses = [];
-    const unobserved = [];
-    for (const id of ids) {
-        signal?.throwIfAborted();
-        try {
-            const observed = await readBudgetedStatus(path, id, { aperture: "monitoring", ordinaryBudget: remaining });
-            statuses.push(observed.status);
-            remaining -= observed.ordinarySelected;
-        }
-        catch (error) {
-            if (error instanceof AkumaNotBornError)
-                throw error;
-            unobserved.push({ id, diagnostic: observationDiagnostic(error) });
-        }
-    }
-    return { statuses, unobserved };
-}
-export async function executeWaitAkuma(input) {
-    const deadline = input.timeoutMs === undefined ? undefined : performance.now() + input.timeoutMs;
-    for (;;) {
-        const round = await observeWaitRound(input.path, input.ids, input.signal);
-        const settled = round.statuses.map(defaultWaitComplete);
-        const completed = round.statuses.length > 0 &&
-            (input.completion === "any" ? settled.some(Boolean) : round.unobserved.length === 0 && settled.every(Boolean));
-        if (completed || (deadline !== undefined && performance.now() >= deadline)) {
-            return fleetResultSchemas.wait.parse({
-                completion: input.completion,
-                observations: await observeAkumaSet(round.statuses, input.path, input.repo),
-                unobserved: round.unobserved,
-            });
-        }
-        await delay(deadline === undefined ? POLL_MS : Math.min(POLL_MS, Math.max(0, deadline - performance.now())), input.signal);
-    }
-}
-export async function executeTellAkuma(input) {
-    input.signal?.throwIfAborted();
-    const handle = source(input.path).of({ id: input.id });
-    const tell = input.tellId === undefined
-        ? await handle.tell(input.body)
-        : await tellAkumaWithId({
-            worldPath: input.path,
-            id: input.id,
-            body: input.body,
-            tellId: input.tellId,
-            ...(input.recordedAt === undefined ? {} : { recordedAt: input.recordedAt }),
-        });
-    input.signal?.throwIfAborted();
-    return fleetResultSchemas.tell.parse({
-        akuma: input.id,
-        tell,
-    });
-}
-export async function executeKillAkuma(input) {
-    input.signal?.throwIfAborted();
-    const handles = input.ids.map((id) => source(input.path).of({ id }));
-    const evidence = await Promise.all(handles.map(async (handle) => await handle.kill()));
-    input.signal?.throwIfAborted();
-    return fleetResultSchemas.kill.parse({
-        results: input.ids.map((id, index) => ({ id, evidence: evidence[index] })),
-    });
-}
-function forwardedFleetCommandResult(response, action) {
-    if (response.kind === "returned") {
-        if (action === "akuma.wait" && isWaitResult(response.result))
-            return response.result;
-        if (action === "akuma.tell" && isTellResult(response.result))
-            return response.result;
-        if (action === "akuma.kill" && isKillResult(response.result))
-            return response.result;
-        throw new Error(`transport integrity: request Fleet ${action} returned an invalid live result`);
-    }
-    throw new Error("Akuma body request terminal Fleet reference cannot reproduce an expired live result");
-}
-const nonblankTextSchema = z.string().refine((value) => value.trim() !== "");
-const fleetTargetsSchema = z
-    .array(akumaIdSchema)
-    .min(1)
-    .superRefine((ids, context) => {
-    if (ids.some((id, index) => index > 0 && ids[index - 1] >= id))
-        context.addIssue({ code: "custom", message: "expected a strictly ordered target set" });
-});
-const waitRequestSchema = z
-    .object({
-    targets: fleetTargetsSchema,
-    completion: z.enum(["any", "all"]),
-    timeoutMs: z.number().int().nonnegative().optional(),
-})
-    .strict()
-    .transform(({ timeoutMs, ...request }) => ({
-    action: "akuma.wait",
-    ...request,
-    ...(timeoutMs === undefined ? {} : { timeoutMs }),
-}));
-const tellRequestSchema = z
-    .object({ target: akumaIdSchema, body: z.string() })
-    .strict()
-    .transform((request) => ({ action: "akuma.tell", ...request }));
-const killRequestSchema = z
-    .object({ targets: fleetTargetsSchema })
-    .strict()
-    .transform((request) => ({ action: "akuma.kill", ...request }));
-const waitServiceSchema = z.object({ action: z.literal("akuma.wait") }).strict();
-const tellServiceSchema = z
-    .object({ action: z.literal("akuma.tell"), target: akumaIdSchema, tellId: nonblankTextSchema })
-    .strict();
-const killServiceSchema = z
-    .object({
-    action: z.literal("akuma.kill"),
-    results: z.array(z.object({ id: akumaIdSchema, evidence: fleetResultSchemas.killEvidence }).strict()),
-})
-    .strict();
-function decodeFleetExecutionContext(value) {
-    const context = fleetPayload(value);
-    if (context === null ||
-        typeof context.id !== "string" ||
-        context.id.trim() === "" ||
-        typeof context.admittedAt !== "string" ||
-        !isAbortSignal(context.signal) ||
-        !isFleetRequestPort(context.upstream))
-        throw new Error("invalid Fleet execution context");
-    return {
-        id: context.id,
-        admittedAt: context.admittedAt,
-        signal: context.signal,
-        upstream: context.upstream,
-    };
-}
-function isAbortSignal(value) {
-    return (value !== null &&
-        typeof value === "object" &&
-        typeof value.throwIfAborted === "function");
-}
-function isFleetRequestPort(value) {
-    const port = fleetPayload(value);
-    return (port !== null &&
-        typeof port.wait === "function" &&
-        typeof port.tell === "function" &&
-        typeof port.kill === "function");
-}
-function fleetPayload(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : null;
-}
-function decodeFleetRequest(action, value) {
-    const schema = action === "akuma.wait" ? waitRequestSchema : action === "akuma.tell" ? tellRequestSchema : killRequestSchema;
-    const parsed = schema.safeParse(value);
-    return parsed.success ? parsed.data : null;
-}
-function decodeFleetService(action, value) {
-    const schema = action === "akuma.wait" ? waitServiceSchema : action === "akuma.tell" ? tellServiceSchema : killServiceSchema;
-    const parsed = schema.safeParse(value);
-    if (!parsed.success)
-        throw new Error("malformed stored Fleet service evidence");
-    return parsed.data;
-}
-/** Fleet owns its Body Request payload, live result, and durable service codecs. */
-export function fleetRequestCommand(action) {
-    return {
-        action,
-        encodeRequest: (request) => {
-            const { action: _action, ...payload } = request;
-            return payload;
-        },
-        decodeRequest: (payload) => decodeFleetRequest(action, payload),
-        encodeResult: (result) => result,
-        decodeResult: (result) => {
-            const schema = action === "akuma.wait"
-                ? fleetResultSchemas.wait
-                : action === "akuma.tell"
-                    ? fleetResultSchemas.tell
-                    : fleetResultSchemas.kill;
-            const parsed = schema.safeParse(result);
-            if (!parsed.success)
-                throw new Error(`Akuma body request returned an invalid live result for ${action}`);
-            return parsed.data;
-        },
-        encodeService: (service) => decodeFleetService(action, service),
-        decodeService: (service) => decodeFleetService(action, service),
-        projectService: (service) => decodeFleetService(action, service),
-        decodeReference: (reference) => decodeFleetService(action, reference),
-        isPermitted: (allowed) => action === "akuma.wait" || allowed.includes(action),
-        decodeExecutionContext: decodeFleetExecutionContext,
-        execute: async (request, context) => {
-            if (request.action === "akuma.wait") {
-                return {
-                    result: await context.upstream.wait({ ...request, signal: context.signal }),
-                    service: { action: request.action },
-                };
-            }
-            if (request.action === "akuma.tell") {
-                return {
-                    result: await context.upstream.tell({
-                        target: request.target,
-                        body: request.body,
-                        tellId: context.id,
-                        recordedAt: context.admittedAt,
-                        signal: context.signal,
-                    }),
-                    service: { action: request.action, target: request.target, tellId: context.id },
-                };
-            }
-            const result = await context.upstream.kill({ targets: request.targets, signal: context.signal });
-            if ("result" in result)
-                return { result: result.result, service: { action: request.action, results: result.service } };
-            return {
-                result,
-                service: { action: request.action, results: result.results.map(({ id, evidence }) => ({ id, evidence })) },
-            };
-        },
-    };
-}
-export function fleetRequestCommands() {
-    return {
-        "akuma.wait": eraseRequestCommand(fleetRequestCommand("akuma.wait")),
-        "akuma.tell": eraseRequestCommand(fleetRequestCommand("akuma.tell")),
-        "akuma.kill": eraseRequestCommand(fleetRequestCommand("akuma.kill")),
-    };
-}
-function needsDispatchAttach(association) {
-    return association.kind === "none";
-}
-async function attachObservationContract(repo, observation) {
-    if (repo === undefined || !needsDispatchAttach(observation.contract))
-        return observation;
-    return { ...observation, contract: await dispatchAssociation(repo, observation.status.id) };
-}
-async function attachWaitContracts(repo, result) {
-    if (repo === undefined)
-        return result;
+async function attachWaitAssociations(path, repo, result) {
+    const created = await createdTasksFor(path, result.observations.map((observation) => observation.status));
     return fleetResultSchemas.wait.parse({
         ...result,
-        observations: await Promise.all(result.observations.map((observation) => attachObservationContract(repo, observation))),
+        observations: await Promise.all(result.observations.map(async (observation, index) => parseAkumaObservation({
+            status: observation.status,
+            contract: await dispatchAssociation(repo, observation.status.id),
+            createdTasks: created[index],
+        }))),
     });
 }
 function directAddress(values) {
@@ -377,42 +103,34 @@ export async function waitAkuma(input, execution = localExecutionContext()) {
     const selected = completion ?? "all";
     const timeoutMs = timeout(values.timeoutMs);
     const channel = executionChannel(execution);
+    const repo = values.repo;
     if (channel.kind === "body-request") {
-        const response = await requestBodyCommand({
+        return await attachWaitAssociations(addressed.path, repo, await requestForwardedFleetWait({
             directory: channel.directory,
-            command: fleetRequestCommand("akuma.wait"),
-            value: {
-                action: "akuma.wait",
-                targets: addressed.ids,
-                completion: selected,
-                ...(timeoutMs === undefined ? {} : { timeoutMs }),
-            },
-        });
-        return await attachWaitContracts(values.repo, forwardedFleetCommandResult(response, "akuma.wait"));
+            targets: addressed.ids,
+            completion: selected,
+            ...(timeoutMs === undefined ? {} : { timeoutMs }),
+        }));
     }
-    return await executeWaitAkuma({
+    return await attachWaitAssociations(addressed.path, repo, await executeWaitAkuma({
         path: addressed.path,
         ids: addressed.ids,
         completion: selected,
         ...(timeoutMs === undefined ? {} : { timeoutMs }),
-        ...(values.repo === undefined ? {} : { repo: values.repo }),
-    });
+    }));
 }
 export async function killAkuma(input, execution = localExecutionContext()) {
     const addressed = await addressAkumaSet(input);
     const channel = executionChannel(execution);
     if (channel.kind === "body-request") {
-        const response = await requestBodyCommand({
+        return await requestForwardedFleetKill({
             directory: channel.directory,
-            command: fleetRequestCommand("akuma.kill"),
-            value: { action: "akuma.kill", targets: addressed.ids },
+            targets: addressed.ids,
         });
-        return forwardedFleetCommandResult(response, "akuma.kill");
     }
     return await executeKillAkuma({
         path: addressed.path,
         ids: addressed.ids,
-        ...(input.repo === undefined ? {} : { repo: input.repo }),
     });
 }
 export async function tellAkuma(input, execution = localExecutionContext()) {
@@ -427,18 +145,16 @@ export async function tellAkuma(input, execution = localExecutionContext()) {
     const addressed = await addressAkuma(directAddress(values));
     const channel = executionChannel(execution);
     if (channel.kind === "body-request") {
-        const response = await requestBodyCommand({
+        return await requestForwardedFleetTell({
             directory: channel.directory,
-            command: fleetRequestCommand("akuma.tell"),
-            value: { action: "akuma.tell", target: addressed.id, body: values.body },
+            target: addressed.id,
+            body: values.body,
         });
-        return forwardedFleetCommandResult(response, "akuma.tell");
     }
     return await executeTellAkuma({
         path: addressed.path,
         id: addressed.id,
         body: values.body,
-        ...(values.repo === undefined ? {} : { repo: values.repo }),
     });
 }
 export async function interruptAkuma(input) {

package/build/src/library/keiyaku.d.ts

@@ -3,13 +3,14 @@ import { composeLibrary } from "./composition.js";
 import { type LibraryExecution } from "../akuma/requests.js";
 export { AuthorityCorruptionError } from "../core/facts/errors.js";
 export { Delivery, KeiyakuRefused, KeiyakuRetry } from "./contract.js";
+export { projectMutationFinality } from "./contract.js";
 export { NoGitWorldError, Repo } from "./repo.js";
 export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError, worktreeHooksFrom } from "./configuration.js";
 export { AkumaWorldScopeError } from "./address.js";
 export { bodyRequestExecution } from "../akuma/requests.js";
 export type { LibraryExecution } from "../akuma/requests.js";
 export type { LocalContractComposition } from "./contract.js";
-export type { AbandonInput, ActorId, AmendInput, AmendResult, ArcInput, AttestationVerdict, AuditInput, AuditReport, DeliveryPreparationRefusal, BindInput, BindResult, AfterEndpointObservation, ContractAfterEdge, ContractBoard, ContractDependent, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractHistory, ContractHistoryEvent, ContractListInput, ContractObservation, ContractObservationInput, ContractPhase, ContractRow, ContractWorkspaceObservation, ContinuationReport, DeliverInput, Fact, IntegrationConflictMaterialized, FactKind, KeiyakuOfInput, KeiyakuRefusal, KeiyakuRetryReason, Lag, MutationResult, PlacementStop, ReconcileReport, Review, ReviewInput, TaskId, TopologyEffect, VerificationReuse, VerificationStop, } from "./contract.js";
+export type { AbandonInput, ActorId, AmendInput, AmendResult, ArcInput, AttestationVerdict, AuditInput, AuditReport, DeliveryPreparationRefusal, BindInput, BindResult, AfterEndpointObservation, ContractAfterEdge, ContractBoard, ContractDependent, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractHistory, ContractHistoryEvent, ContractListInput, ContractObservation, ContractObservationInput, ContractPhase, ContractRow, ContractWorkspaceObservation, ContinuationReport, DeliverInput, Fact, IntegrationConflictMaterialized, FactKind, KeiyakuOfInput, KeiyakuRefusal, KeiyakuRetryReason, Lag, MutationResult, MutationFinality, MutationFinalityInput, MutationFinalitySurface, MutationPendingSurface, PlacementStop, ReconcileReport, Review, ReviewInput, TaskId, TopologyEffect, VerificationReuse, VerificationStop, } from "./contract.js";
 export type { ContractId, ContractState, ChangeId, SnapshotId } from "../core/facts/types.js";
 export type { Gate, GatesFromInput, HookCommand, RequireBranchesToBeUpToDateFromInput, WorktreeHooks, } from "./configuration.js";
 export type { RegionOverlap } from "./region.js";
@@ -21,13 +22,16 @@ export type { Dispatch, DispatchFailure } from "../dispatch/index.js";
 export type { AkumaAlias } from "../identity/selector.js";
 export type { AkumaGlob } from "../identity/selector.js";
 export type { AkuId } from "../akuma/identity.js";
-export type { TellResult, TellWake } from "./fleet.js";
+export type { TellResult, TellWake } from "../akuma/index.js";
 export type { AllowedAction, AllowedActions } from "../akuma/allowed.js";
 export type { Catalog, CatalogInput, CatalogQuery } from "./catalog.js";
 export type { NukeInput, NukeResult } from "./nuke.js";
 export type { NukeConfirmationRefusal, NukeConfirmationRequiredRefusal } from "./refusal.js";
 export type { AkumaAddressInput, AkumaSetAddressInput, AkumaWorldScopeRefusal, DirectAkumaSelector, SetAkumaSelector, } from "./address.js";
-export type { AkumaHistoryInput, AkumaHistoryResult, AkumaInterruptInput, AkumaInterruptResult, AkumaKillResult, AkumaObservation, AkumaObservationStage, AkumaTellInput, AkumaUnobserved, CreatedTaskObservation, DispatchAssociation, AkumaTellResult, AkumaWaitInput, AkumaWaitResult, } from "./fleet.js";
+export type { CreatedTaskObservation } from "../task/created-observation.js";
+export type { DispatchAssociation } from "../dispatch/association.js";
+export type { AkumaKillResult, AkumaObservation, AkumaObservationStage, AkumaTellResult, AkumaUnobserved, AkumaWaitResult, } from "../akuma/fleet-observation.js";
+export type { AkumaHistoryInput, AkumaHistoryResult, AkumaInterruptInput, AkumaInterruptResult, AkumaTellInput, AkumaWaitInput, } from "./fleet.js";
 export type Keiyaku = KeiyakuType;
 export type KeiyakuLibrary = ReturnType<typeof composeLibrary>;
 declare function routedLibrary(input: Readonly<{

package/build/src/library/keiyaku.js

@@ -3,6 +3,7 @@ import { composeLibrary } from "./composition.js";
 import { libraryExecutionInput, localExecutionContext } from "../akuma/requests.js";
 export { AuthorityCorruptionError } from "../core/facts/errors.js";
 export { Delivery, KeiyakuRefused, KeiyakuRetry } from "./contract.js";
+export { projectMutationFinality } from "./contract.js";
 export { NoGitWorldError, Repo } from "./repo.js";
 export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError, worktreeHooksFrom } from "./configuration.js";
 export { AkumaWorldScopeError } from "./address.js";