@astrosheep/keiyaku 4.6.4 → 4.6.7

package/build/src/git/workspace.d.ts

@@ -2,8 +2,9 @@ import { z } from "zod";
 import type { ContractId, SnapshotId } from "../core/facts/types.js";
 import { type GitObjectId } from "./identity.js";
 import { type GitRepository } from "./process.js";
+import type { GitReadObservation } from "./read-observation.js";
 import type { ContractWorkspaceLocation } from "../workspace-place.js";
-export type WorkspaceChanges = Readonly<{
+type WorkspaceChanges = Readonly<{
     staged: readonly string[];
     unstaged: readonly string[];
     untracked: readonly string[];
@@ -19,7 +20,7 @@ export type WorkspaceTree = Readonly<{
 export declare function worktreePath(repository: GitRepository, place: string): string;
 /** Check out a captured candidate tree in the appointed detached worktree. */
 export declare function checkoutDetachedSnapshot(repository: GitRepository, workspace: string, snapshot: SnapshotId): Promise<void>;
-export type DependentWorktreeFollow = Readonly<{
+type DependentWorktreeFollow = Readonly<{
     kind: "followed";
     before: SnapshotId;
     after: SnapshotId;
@@ -42,7 +43,7 @@ export declare function workspaceMergeHead(repository: GitRepository, workspace:
 export declare function workspaceMergeStatePresent(repository: GitRepository, workspace: string): Promise<boolean>;
 /** Sorted unique unmerged index paths from porcelain status. */
 export declare function unmergedWorkspacePaths(repository: GitRepository, workspace: string): Promise<readonly string[]>;
-export type WorkspaceChangeCounts = Readonly<{
+type WorkspaceChangeCounts = Readonly<{
     staged: number;
     unstaged: number;
     untracked: number;
@@ -55,7 +56,7 @@ export declare const conflictRecoverySchema: z.ZodObject<{
 }, z.core.$strict>;
 type ConflictRecovery = z.infer<typeof conflictRecoverySchema>;
 export declare const conflictRecovery: ConflictRecovery;
-export type ContractWorkspaceMerge = Readonly<{
+type ContractWorkspaceMerge = Readonly<{
     head: SnapshotId;
     unmergedPaths: readonly string[];
     handoffBase?: SnapshotId;
@@ -100,7 +101,16 @@ export declare function observeWorkspace(repository: GitRepository, location: Co
 export declare function observeTargetLag(repository: GitRepository, workspace: string, head: SnapshotId | null | undefined): Promise<ContractTargetLag>;
 /** Capture tracked and untracked workspace bytes without changing its real index. */
 export declare function captureWorkspaceTree(repository: GitRepository, workspace: string): Promise<WorkspaceTree>;
-export type HandoffRetirement = Readonly<{
+export type HandoffReceiptCoordinate = Readonly<{
+    contractId: ContractId;
+    place: string;
+    workspace: string;
+}>;
+export type ConflictHandoff = Readonly<{
+    base: SnapshotId;
+    mergeHead: SnapshotId;
+}>;
+type HandoffRetirement = Readonly<{
     kind: "absent" | "active" | "orphan-retired" | "retired";
 }> | Readonly<{
     kind: "retained";
@@ -113,14 +123,8 @@ export declare function recordConflictHandoff(repository: GitRepository, input:
     head: SnapshotId;
     mergeHead: SnapshotId;
 }>): Promise<void>;
-export declare function conflictHandoffFor(repository: GitRepository, input: Readonly<{
-    contractId: ContractId;
-    place: string;
-    workspace: string;
-}>): Promise<Readonly<{
-    base: SnapshotId;
-    mergeHead: SnapshotId;
-}> | undefined>;
+/** Read selected handoff refs once and decode their receipts through the call's blob channel. */
+export declare function readConflictHandoffs(repository: GitRepository, readBlobs: GitReadObservation["readBlobs"], coordinates: readonly HandoffReceiptCoordinate[]): Promise<ReadonlyMap<ContractId, ConflictHandoff>>;
 export declare function retireConflictHandoff(repository: GitRepository, input: Readonly<{
     contractId: ContractId;
     place: string;

package/build/src/git/workspace.js

@@ -2,20 +2,21 @@ import { z } from "zod";
 import { access, mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
+import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { contractPhysicalName, gitObjectId, mintSnapshotId } from "./identity.js";
-import { GitPlumbingError, runGit, runGitWithEnvironment } from "./process.js";
-import { HANDOFF_RECEIPT_REF_NAMESPACE, readBlob, readRef, worktreeGitDirectory, writeBlob } from "./repository.js";
+import { executeGit, GitPlumbingError } from "./process.js";
+import { HANDOFF_RECEIPT_REF_NAMESPACE, readBlob, readRef, readRefs, worktreeGitDirectory, writeBlob, } from "./repository.js";
 const WORKTREE_DIRECTORY = [".keiyaku", "wt"];
 export function worktreePath(repository, place) {
     return resolve(repository.primaryWorktree, ...WORKTREE_DIRECTORY, place);
 }
 /** Check out a captured candidate tree in the appointed detached worktree. */
 export async function checkoutDetachedSnapshot(repository, workspace, snapshot) {
-    await runGit(repository, ["-C", workspace, "checkout", "--quiet", "--force", "--detach", gitObjectId(snapshot)]);
+    await executeGit(repository, ["-C", workspace, "checkout", "--quiet", "--force", "--detach", gitObjectId(snapshot)]);
 }
 async function workspaceRevision(repository, workspace, revision) {
     try {
-        const value = (await runGit(repository, ["-C", workspace, "rev-parse", "--verify", "--quiet", revision]))
+        const value = (await executeGit(repository, ["-C", workspace, "rev-parse", "--verify", "--quiet", revision]))
             .toString("utf8")
             .trim();
         return value.length === 0 ? null : mintSnapshotId(value);
@@ -37,7 +38,7 @@ async function workspaceOperationState(repository, workspace, gitDirectory) {
             return false;
         }
     }));
-    const unmerged = (await runGit(repository, ["-C", workspace, "ls-files", "--unmerged", "-z"])).length > 0;
+    const unmerged = (await executeGit(repository, ["-C", workspace, "ls-files", "--unmerged", "-z"])).length > 0;
     return { other: other.some(Boolean), unmerged };
 }
 /** Follow a dependency baseline only through a clean, detached fast-forward. */
@@ -58,7 +59,7 @@ export async function followDependentManagedWorktree(repository, workspace, targ
             ...status.unmergedPaths,
         ]),
     ].sort();
-    const attached = await runGit(repository, ["-C", workspace, "symbolic-ref", "--quiet", "HEAD"]).then(() => true, (error) => {
+    const attached = await executeGit(repository, ["-C", workspace, "symbolic-ref", "--quiet", "HEAD"]).then(() => true, (error) => {
         if (error instanceof GitPlumbingError && error.status === 1)
             return false;
         throw error;
@@ -72,7 +73,7 @@ export async function followDependentManagedWorktree(repository, workspace, targ
         return { kind: "unchanged" };
     let ancestor = false;
     try {
-        await runGit(repository, ["merge-base", "--is-ancestor", gitObjectId(head), gitObjectId(target)]);
+        await executeGit(repository, ["merge-base", "--is-ancestor", gitObjectId(head), gitObjectId(target)]);
         ancestor = true;
     }
     catch (error) {
@@ -81,17 +82,26 @@ export async function followDependentManagedWorktree(repository, workspace, targ
     }
     if (!ancestor)
         return { kind: "retained", head, reason: "head-moved", paths };
-    await runGit(repository, ["-C", workspace, "checkout", "--quiet", "--detach", gitObjectId(target)]);
+    await executeGit(repository, ["-C", workspace, "checkout", "--quiet", "--detach", gitObjectId(target)]);
     return { kind: "followed", before: head, after: target };
 }
 export async function withPrivateGitIndex(action) {
     const directory = await mkdtemp(join(tmpdir(), "keiyaku-v4-index-"));
+    let value;
     try {
-        return await action({ GIT_INDEX_FILE: join(directory, "index") });
+        value = await action({ GIT_INDEX_FILE: join(directory, "index") });
     }
-    finally {
-        await rm(directory, { recursive: true, force: true });
+    catch (error) {
+        try {
+            await rm(directory, { recursive: true, force: true });
+        }
+        catch (cleanup) {
+            throw new AggregateError([error, cleanup], "Private Git index capture and cleanup failed");
+        }
+        throw error;
     }
+    await rm(directory, { recursive: true, force: true });
+    return value;
 }
 function fields(record, count) {
     const result = [];
@@ -107,15 +117,7 @@ function fields(record, count) {
     return result;
 }
 async function workspaceStatus(repository, workspace) {
-    const records = (await runGit(repository, [
-        "-C",
-        workspace,
-        "status",
-        "--porcelain=v2",
-        "-z",
-        "--untracked-files=all",
-        "--ignore-submodules=none",
-    ]))
+    const records = (await executeGit(repository, ["-C", workspace, "status", "--porcelain=v2", "-z", "--untracked-files=all", "--ignore-submodules=none"], undefined, { GIT_OPTIONAL_LOCKS: "0" }))
         .toString("utf8")
         .split("\0");
     const staged = new Set();
@@ -172,7 +174,7 @@ async function workspaceChanges(repository, workspace) {
 /** Observe MERGE_HEAD in an appointed workspace, or undefined when absent. */
 export async function workspaceMergeHead(repository, workspace) {
     try {
-        return mintSnapshotId((await runGit(repository, ["-C", workspace, "rev-parse", "-q", "--verify", "MERGE_HEAD"]))
+        return mintSnapshotId((await executeGit(repository, ["-C", workspace, "rev-parse", "-q", "--verify", "MERGE_HEAD"]))
             .toString("utf8")
             .trim());
     }
@@ -250,7 +252,7 @@ export async function observeTargetLag(repository, workspace, head) {
     if (head === null)
         return { kind: "unknown", subject };
     try {
-        const text = (await runGit(repository, ["-C", workspace, "rev-list", "--count", `HEAD..${head}`]))
+        const text = (await executeGit(repository, ["-C", workspace, "rev-list", "--count", `HEAD..${head}`]))
             .toString("utf8")
             .trim();
         if (!/^[0-9]+$/u.test(text))
@@ -265,7 +267,7 @@ export async function observeTargetLag(repository, workspace, head) {
 }
 /** Capture tracked and untracked workspace bytes without changing its real index. */
 export async function captureWorkspaceTree(repository, workspace) {
-    const identities = (await runGit(repository, ["-C", workspace, "show", "-s", "--format=%H%n%T%n%cI", "HEAD"]))
+    const identities = (await executeGit(repository, ["-C", workspace, "show", "-s", "--format=%H%n%T%n%cI", "HEAD"]))
         .toString("utf8")
         .split("\n");
     if (identities.length !== 4 ||
@@ -285,10 +287,10 @@ export async function captureWorkspaceTree(repository, workspace) {
     if (!dirty)
         return { tree, head, at, dirty, changes };
     return await withPrivateGitIndex(async (environment) => {
-        await runGitWithEnvironment(repository, ["-C", workspace, "read-tree", "HEAD"], undefined, environment);
-        await runGitWithEnvironment(repository, ["-C", workspace, "add", "--all"], undefined, environment);
+        await executeGit(repository, ["-C", workspace, "-c", "core.splitIndex=false", "read-tree", gitObjectId(head)], undefined, environment);
+        await executeGit(repository, ["-C", workspace, "-c", "core.splitIndex=false", "add", "--all"], undefined, environment);
         return {
-            tree: gitObjectId((await runGitWithEnvironment(repository, ["-C", workspace, "write-tree"], undefined, environment))
+            tree: gitObjectId((await executeGit(repository, ["-C", workspace, "-c", "core.splitIndex=false", "write-tree"], undefined, environment))
                 .toString("utf8")
                 .trim(), "workspace tree"),
             head,
@@ -320,6 +322,11 @@ function receiptFor(value) {
         mergeHead: mintSnapshotId(record.mergeHead),
     };
 }
+function receiptMatches(receipt, coordinate) {
+    return (receipt.contractId === coordinate.contractId &&
+        receipt.place === coordinate.place &&
+        receipt.workspace === resolve(coordinate.workspace));
+}
 async function storedHandoffReceipt(repository, contractId, place) {
     const ref = handoffRefFor(contractId, place);
     const oid = await readRef(repository, ref);
@@ -329,7 +336,7 @@ async function storedHandoffReceipt(repository, contractId, place) {
     return { receipt, ref, oid };
 }
 async function removeHandoffReceipt(repository, stored) {
-    await runGit(repository, ["update-ref", "--no-deref", "-d", stored.ref, stored.oid]);
+    await executeGit(repository, ["update-ref", "--no-deref", "-d", stored.ref, stored.oid]);
 }
 export async function recordConflictHandoff(repository, input) {
     const ref = handoffRefFor(input.contractId, input.place);
@@ -345,27 +352,37 @@ export async function recordConflictHandoff(repository, input) {
         mergeHead: input.mergeHead,
     };
     const oid = await writeBlob(repository, `${JSON.stringify(receipt)}\n`);
-    await runGit(repository, ["update-ref", "--no-deref", ref, oid, "0".repeat(oid.length)]);
+    await executeGit(repository, ["update-ref", "--no-deref", ref, oid, "0".repeat(oid.length)]);
 }
-export async function conflictHandoffFor(repository, input) {
-    const stored = await storedHandoffReceipt(repository, input.contractId, input.place);
-    if (stored === null)
-        return undefined;
-    if (stored.receipt.contractId !== input.contractId ||
-        stored.receipt.place !== input.place ||
-        stored.receipt.workspace !== resolve(input.workspace)) {
-        return undefined;
+/** Read selected handoff refs once and decode their receipts through the call's blob channel. */
+export async function readConflictHandoffs(repository, readBlobs, coordinates) {
+    const byRef = new Map();
+    for (const coordinate of coordinates)
+        byRef.set(handoffRefFor(coordinate.contractId, coordinate.place), coordinate);
+    if (byRef.size === 0)
+        return new Map();
+    const resolved = await readRefs(repository, [...byRef.keys()]);
+    const present = [...resolved].flatMap(([ref, oid]) => (oid === null ? [] : [{ ref, oid }]));
+    const blobs = await readBlobs(present.map(({ oid }) => oid));
+    const handoffs = new Map();
+    for (const { ref, oid } of present) {
+        const result = blobs.get(oid);
+        if (result?.kind !== "present")
+            throw new AuthorityCorruptionError(`Git handoff receipt is missing: ${ref}`);
+        const receipt = receiptFor(JSON.parse(result.bytes.toString("utf8")));
+        const coordinate = byRef.get(ref);
+        if (!receiptMatches(receipt, coordinate))
+            continue;
+        handoffs.set(coordinate.contractId, { base: receipt.head, mergeHead: receipt.mergeHead });
     }
-    return { base: stored.receipt.head, mergeHead: stored.receipt.mergeHead };
+    return handoffs;
 }
 export async function retireConflictHandoff(repository, input) {
     const stored = await storedHandoffReceipt(repository, input.contractId, input.place);
     if (stored === null)
         return { kind: "absent" };
     const { receipt } = stored;
-    if (receipt.contractId !== input.contractId ||
-        receipt.place !== input.place ||
-        receipt.workspace !== resolve(input.workspace)) {
+    if (!receiptMatches(receipt, input)) {
         return { kind: "retained", reason: "receipt-mismatch" };
     }
     const gitDirectory = await worktreeGitDirectory(repository, input.workspace);
@@ -389,7 +406,7 @@ export async function retireConflictHandoff(repository, input) {
     }
     if (!input.consume)
         return { kind: "active" };
-    await runGit(repository, ["-C", input.workspace, "merge", "--quit"]);
+    await executeGit(repository, ["-C", input.workspace, "merge", "--quit"]);
     await removeHandoffReceipt(repository, stored);
     return { kind: "retired" };
 }

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

@@ -1,5 +1,5 @@
-export { kanshi, observeKanshi } from "./read.js";
+export { kanshi, kanshiCategory, observeKanshi } from "./read.js";
 export { selectKanshi, selectRegion } from "./select.js";
 export type { KanshiInput } from "./read.js";
-export type { AkumaKanshiRow, AkumaKanshiWorld, ContractEndpointObservation, ContractHolderObservation, ContractKanshiBoard, ContractKanshiRow, KanshiReport, Section, TaskKanshiRow, TaskKanshiWorld, KanshiRegionSelection, RegionDeclaration, RegionOverlap, RegionRead, } from "./report.js";
+export type { AkumaKanshiRow, AkumaKanshiWorld, ContractEndpointObservation, ContractHolderObservation, ContractKanshiBoard, ContractKanshiRow, KanshiCategoryReport, KanshiReport, Section, TaskKanshiRow, TaskKanshiWorld, KanshiRegionSelection, RegionDeclaration, RegionOverlap, RegionRead, } from "./report.js";
 export type { KanshiSelection } from "./select.js";

package/build/src/kanshi/index.js

@@ -1,2 +1,2 @@
-export { kanshi, observeKanshi } from "./read.js";
+export { kanshi, kanshiCategory, observeKanshi } from "./read.js";
 export { selectKanshi, selectRegion } from "./select.js";

package/build/src/kanshi/read.d.ts

@@ -2,7 +2,7 @@ import { type AliasBinding } from "../alias/index.js";
 import { Repo } from "../library/repo.js";
 import type { ContractBoard } from "../protocol/read/status.js";
 import type { WorldRoot } from "../world.js";
-import type { KanshiRegionSelection, KanshiReport, Section } from "./report.js";
+import type { KanshiCategoryReport, KanshiRegionSelection, KanshiReport, Section } from "./report.js";
 export type KanshiInput = Readonly<{
     world: WorldRoot | null;
     repo?: Repo;
@@ -15,3 +15,10 @@ export type KanshiObservation = Readonly<{
 }>;
 export declare function observeKanshi(input: KanshiInput): Promise<KanshiObservation>;
 export declare function kanshi(input: KanshiInput): Promise<KanshiReport>;
+export type KanshiCategoryInput = Readonly<{
+    world: WorldRoot | null;
+    repo?: Repo;
+    category: KanshiCategoryReport["category"];
+    limit?: number;
+}>;
+export declare function kanshiCategory(input: KanshiCategoryInput): Promise<KanshiCategoryReport>;

package/build/src/kanshi/read.js

@@ -1,5 +1,5 @@
 import { withoutReportedChanges } from "../akuma/projection.js";
-import { readAkumaRoster, readAkumaTimeline } from "../akuma/akuma.js";
+import { observeAkumaRoster, readAkumaTimeline } from "../akuma/akuma.js";
 import { readAliases } from "../alias/index.js";
 import { decodeContractDocument } from "../body/decode.js";
 import { assertRegionPattern } from "../body/region.js";
@@ -16,6 +16,7 @@ import { observeRecentTaskStatus, TaskAuthorityCorruptionError } from "../task/i
 import { observeTaskBoard } from "../task/operations.js";
 import { ROSTER_SNAPSHOT_ROWS, ROSTER_VISIBLE_ROWS } from "./roster.js";
 import { selectKanshi, selectRegion } from "./select.js";
+const WORLD_CONTRACT_ROWS = 10;
 function diagnostic(error) {
     let source;
     if (error instanceof Error)
@@ -128,12 +129,12 @@ async function readBranch(repo) {
         return null;
     }
 }
-async function readContracts(observation, include) {
+async function readContracts(observation, include, limit = WORLD_CONTRACT_ROWS) {
     try {
         return {
             kind: "present",
             value: include === undefined
-                ? await readContractCatalogue(observation, 10)
+                ? await readContractCatalogue(observation, limit)
                 : await readContractBoard(observation, include),
         };
     }
@@ -282,11 +283,12 @@ async function claimedAssociatedContracts(observation, dispatches) {
     }));
     return claimed;
 }
-async function joinAkuma(path, observeContract, isContractClaimed, dispatches, aliases) {
+async function joinAkuma(path, observeContract, isContractClaimed, dispatches, input) {
+    const { aliases, limit = ROSTER_VISIBLE_ROWS } = input;
     if (aliases.kind !== "present")
         return aliases;
     try {
-        const source = await readAkumaRoster(path, { limit: ROSTER_VISIBLE_ROWS });
+        const source = await observeAkumaRoster(path, limit);
         const aliasById = new Map();
         for (const binding of aliases.value)
             aliasById.set(binding.akuId, [...(aliasById.get(binding.akuId) ?? []), binding]);
@@ -355,7 +357,9 @@ async function observeWithoutRepo(world, region, observedAt, branch) {
     const observeContract = contractEndpointObserver(contracts);
     const tasks = world === null ? { kind: "absent" } : await readTasks(world, holders, observeContract);
     const aliases = world === null ? { kind: "absent" } : await readAliasBindings(world);
-    const akuma = world === null ? { kind: "absent" } : await joinAkuma(world, observeContract, () => false, [], aliases);
+    const akuma = world === null
+        ? { kind: "absent" }
+        : await joinAkuma(world, observeContract, () => false, [], { aliases });
     return {
         report: {
             root: world,
@@ -394,7 +398,7 @@ async function observeRepo(input) {
                 ? { kind: "absent" }
                 : dispatches.kind === "failed"
                     ? dispatches
-                    : await joinAkuma(world, observeContract, (id) => claimed.has(id), dispatches.value, aliases);
+                    : await joinAkuma(world, observeContract, (id) => claimed.has(id), dispatches.value, { aliases });
             const assembled = {
                 root: world,
                 observedAt,
@@ -443,6 +447,67 @@ export async function observeKanshi(input) {
 export async function kanshi(input) {
     return (await observeKanshi(input)).report;
 }
+/** Category observations reuse owner rows without reading the Task board. */
+async function observeAkumaCategory(world, repo, limit, observedAt) {
+    const report = (akuma) => ({
+        category: "akuma",
+        root: world,
+        observedAt,
+        akuma,
+    });
+    if (world === null)
+        return report({ kind: "absent" });
+    const composed = async (observation) => {
+        const aliases = await readAliasBindings(world);
+        if (aliases.kind !== "present")
+            return report(aliases);
+        if (observation === undefined)
+            return report(await joinAkuma(world, () => "unavailable", () => false, [], { aliases, limit }));
+        const dispatches = await readDispatches(observation);
+        if (dispatches.kind === "failed")
+            return report(dispatches);
+        const claimed = await claimedAssociatedContracts(observation, dispatches.value);
+        return report(await joinAkuma(world, () => "unavailable", (id) => claimed.has(id), dispatches.value, { aliases, limit }));
+    };
+    if (repo === undefined)
+        return await composed();
+    try {
+        return await withGitDecodeChannel(repo, (channel) => withGitReadObservation(repo, channel, composed));
+    }
+    catch (error) {
+        return report({ kind: "failed", failure: { message: diagnostic(error) } });
+    }
+}
+async function observeContractCategory(world, repo, limit, observedAt) {
+    const report = (contracts) => ({
+        category: "contract",
+        root: world,
+        observedAt,
+        contracts,
+    });
+    try {
+        return await withGitDecodeChannel(repo, (channel) => withGitReadObservation(repo, channel, async (observation) => {
+            const [contracts, holders] = await Promise.all([
+                readContracts(observation, undefined, limit),
+                readHolders(observation),
+            ]);
+            return report(decorateContracts(contracts, holders));
+        }));
+    }
+    catch (error) {
+        return report({ kind: "failed", failure: { message: diagnostic(error) } });
+    }
+}
+export async function kanshiCategory(input) {
+    const observedAt = new Date().toISOString();
+    const { world, repo, category, limit = 10 } = input;
+    if (category === "contract") {
+        if (repo === undefined)
+            throw new TypeError("kanshi contract category requires a Repo");
+        return await observeContractCategory(world, scopeForRepo(repo), limit, observedAt);
+    }
+    return await observeAkumaCategory(world, repo === undefined ? undefined : scopeForRepo(repo), limit, observedAt);
+}
 async function attachSelectedIssue(observation, contracts, selected) {
     if (contracts.kind !== "present")
         return contracts;

package/build/src/kanshi/report.d.ts

@@ -100,4 +100,16 @@ export type KanshiReport = Readonly<{
     akuma: Section<AkumaKanshiWorld>;
     region?: Section<RegionRead>;
 }>;
+/** Internal category observation retains only the requested owner section. */
+export type KanshiCategoryReport = Readonly<{
+    category: "akuma";
+    root: WorldRoot | null;
+    observedAt: string;
+    akuma: Section<AkumaKanshiWorld>;
+}> | Readonly<{
+    category: "contract";
+    root: WorldRoot | null;
+    observedAt: string;
+    contracts: Section<ContractKanshiBoard>;
+}>;
 export type { CurrentPhysicalIssue };

package/build/src/library/akuma-creation.d.ts

@@ -15,8 +15,7 @@ import type { Settings } from "../settings.js";
 import { type WorldRoot } from "../world.js";
 import type { Keiyaku } from "./keiyaku.js";
 import { type Repo } from "./repo.js";
-export type { AkumaStatus } from "../akuma/akuma.js";
-export type IntegrationFailure = Readonly<{
+type IntegrationFailure = Readonly<{
     kind: "authority-corruption" | "infrastructure";
     diagnostic: string;
 }>;
@@ -30,7 +29,7 @@ export type DispatchStage = Readonly<{
     kind: "failed";
     failure: DispatchFailure | IntegrationFailure;
 }>;
-export type AliasStage = Readonly<{
+type AliasStage = Readonly<{
     kind: "none";
 }> | Readonly<{
     kind: "aliased";
@@ -47,7 +46,7 @@ export type CallWaitHead = Readonly<{
     dispatch: DispatchStage;
     alias: AliasStage;
 }>;
-export type CallWaitObserver = Readonly<{
+type CallWaitObserver = Readonly<{
     admitted?: (tell: TellResult, id: AkumaStatus["id"], head: CallWaitHead) => void | Promise<void>;
     observe?: AskObserver["observe"];
 }>;
@@ -117,3 +116,4 @@ export declare function callAkumas(input: CallInput & Readonly<{
 export declare function forkAkumas(input: ForkInput & Readonly<{
     path: WorldRoot;
 }>): Promise<ForkResult>;
+export {};

package/build/src/library/akuma-creation.js

@@ -13,7 +13,7 @@ import { moveAlias } from "../alias/index.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { publishDispatch, readDispatch } from "../dispatch/index.js";
 import { parseAkumaAlias } from "../identity/selector.js";
-import { emitCalledPluginSignal } from "../plugin/akuma-signals.js";
+import { emitPluginSignal, outcomePluginObserver } from "../plugin/akuma-signals.js";
 import { World } from "../world.js";
 import { addressAkuma } from "./address.js";
 import { requireInput } from "./input.js";
@@ -108,9 +108,9 @@ function pluginDiagnostic(error) {
     const message = error instanceof Error ? error.message : String(error);
     return message.length <= 500 ? message : `${message.slice(0, 500)}...`;
 }
-async function recordPluginDiagnostic(paths, error) {
+async function recordPluginDiagnostic(paths, error, occurrence = "call admission") {
     try {
-        await appendFile(paths.log, `plugin call admission failed: ${pluginDiagnostic(error)}\n`);
+        await appendFile(paths.log, `plugin ${occurrence} failed: ${pluginDiagnostic(error)}\n`);
     }
     catch {
         // Plugin diagnostic loss must not change an already admitted call.
@@ -126,22 +126,16 @@ async function emitCalledSignal(input) {
     try {
         const paths = pathsForAkuId(input.path, input.admitted.id);
         const callerAkumaId = input.admitted.requested ? await requestedParent(input.path, input.admitted.id) : undefined;
-        const reportDiagnostic = (message) => {
-            void recordPluginDiagnostic(paths, message);
-        };
-        try {
-            await emitCalledPluginSignal({
-                world: input.path,
-                ...(input.settings === undefined ? {} : { settings: input.settings }),
-                reportDiagnostic,
-                akumaId: input.admitted.id,
-                ...(callerAkumaId === undefined ? {} : { callerAkumaId }),
-                ...(input.contractId === undefined ? {} : { contractId: input.contractId }),
-            });
-        }
-        catch (error) {
-            await recordPluginDiagnostic(paths, error);
-        }
+        await emitPluginSignal({
+            world: input.path,
+            ...(input.settings === undefined ? {} : { settings: input.settings }),
+            reportDiagnostic: (message) => void recordPluginDiagnostic(paths, message),
+        }, {
+            kind: "akuma.called",
+            akumaId: input.admitted.id,
+            ...(callerAkumaId === undefined ? {} : { callerAkumaId }),
+            ...(input.contractId === undefined ? {} : { contractId: input.contractId }),
+        });
     }
     catch {
         // Plugin delivery must not change an already admitted call.
@@ -320,6 +314,13 @@ async function observeCall(input) {
             tellId: input.initialTell.tellId,
             timeoutMs: input.timeoutMs,
             receipt: input.receipt,
+            outcomeObserved: outcomePluginObserver({
+                world: input.path,
+                ...(input.settings === undefined ? {} : { settings: input.settings }),
+                reportDiagnostic: (message) => {
+                    void recordPluginDiagnostic(pathsForAkuId(input.path, input.akuma), message, "outcome observation");
+                },
+            }),
             ...(input.signal === undefined ? {} : { signal: input.signal }),
             onObserve,
         });
@@ -400,6 +401,7 @@ export async function callAkumas(input, execution = localExecutionContext()) {
             initialTell: parsed.initialTell,
             receipt,
             timeoutMs: parsed.timeoutMs,
+            ...(parsed.settings === undefined ? {} : { settings: parsed.settings }),
             ...(parsed.signal === undefined ? {} : { signal: parsed.signal }),
             ...(parsed.observe === undefined ? {} : { observe: parsed.observe }),
         });