@astrosheep/keiyaku 4.5.7 → 4.5.9

package/build/src/git/workspace.js

@@ -70,6 +70,50 @@ export async function followManagedWorktree(repository, workspace, tender) {
     await runGit(repository, ["-C", workspace, "reset", "--mixed", gitObjectId(tender)]);
     return { kind: "followed", before: head, after: tender };
 }
+/** Follow a dependency baseline only through a clean, detached fast-forward. */
+export async function followDependentManagedWorktree(repository, workspace, target) {
+    const head = await workspaceRevision(repository, workspace, "HEAD");
+    if (head === null)
+        throw new Error("managed worktree HEAD is missing");
+    const status = await workspaceStatus(repository, workspace);
+    const gitDirectory = await worktreeGitDirectory(repository, workspace);
+    const operation = await workspaceOperationState(repository, workspace, gitDirectory);
+    const mergeHead = await workspaceRevision(repository, workspace, "MERGE_HEAD");
+    const paths = [
+        ...new Set([
+            ...status.staged,
+            ...status.unstaged,
+            ...status.untracked,
+            ...status.submodules,
+            ...status.unmergedPaths,
+        ]),
+    ].sort();
+    const attached = await runGit(repository, ["-C", workspace, "symbolic-ref", "--quiet", "HEAD"]).then(() => true, (error) => {
+        if (error instanceof GitPlumbingError && error.status === 1)
+            return false;
+        throw error;
+    });
+    if (attached)
+        return { kind: "retained", head, reason: "head-attached", paths };
+    if (mergeHead !== null || operation.other || operation.unmerged || paths.length > 0) {
+        return { kind: "retained", head, reason: "operation-in-progress", paths };
+    }
+    if (head === target)
+        return { kind: "unchanged" };
+    let ancestor = false;
+    try {
+        await runGit(repository, ["merge-base", "--is-ancestor", gitObjectId(head), gitObjectId(target)]);
+        ancestor = true;
+    }
+    catch (error) {
+        if (!(error instanceof GitPlumbingError) || error.status !== 1)
+            throw error;
+    }
+    if (!ancestor)
+        return { kind: "retained", head, reason: "head-moved", paths };
+    await runGit(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-"));
     try {

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

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

package/build/src/kanshi/read.js

@@ -122,22 +122,6 @@ async function readContracts(observation, include) {
         return { kind: "failed", failure: { message: diagnostic(error) } };
     }
 }
-async function attachSelectedIssue(observation, contracts, selected) {
-    if (contracts.kind !== "present")
-        return contracts;
-    try {
-        const rows = await Promise.all(contracts.value.rows.map(async (row) => {
-            if (row.id !== selected)
-                return row;
-            const issue = await observeCurrentPhysicalIssue(observation.repository, row);
-            return issue === undefined ? row : { ...row, issue };
-        }));
-        return { kind: "present", value: { ...contracts.value, rows } };
-    }
-    catch (error) {
-        return { kind: "failed", failure: { message: diagnostic(error) } };
-    }
-}
 async function readHolders(observation) {
     try {
         return { kind: "present", value: await readTaskHolderProjectionAt(observation) };
@@ -393,3 +377,19 @@ export async function observeKanshi(input) {
 export async function kanshi(input) {
     return (await observeKanshi(input)).report;
 }
+async function attachSelectedIssue(observation, contracts, selected) {
+    if (contracts.kind !== "present")
+        return contracts;
+    try {
+        const rows = await Promise.all(contracts.value.rows.map(async (row) => {
+            if (row.id !== selected)
+                return row;
+            const issue = await observeCurrentPhysicalIssue(observation.repository, row);
+            return issue === undefined ? row : { ...row, issue };
+        }));
+        return { kind: "present", value: { ...contracts.value, rows } };
+    }
+    catch (error) {
+        return { kind: "failed", failure: { message: diagnostic(error) } };
+    }
+}

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

@@ -1,11 +1,11 @@
 import type { ContractBoard, ContractDisposition, ContractPhase } from "../library/contract.js";
-import type { CurrentPhysicalIssue } from "../protocol/read/observation.js";
 import type { TaskId, TaskRef, TaskRow } from "../task/index.js";
 import type { AkumaList, AkumaListRow, UnbornAkumaListRow, ActivitySnapshot } from "../akuma/index.js";
 import type { AkumaAlias } from "../identity/selector.js";
 import type { WorldRoot } from "../world.js";
 import type { ContractId } from "../library/contract.js";
 import type { RegionOverlap } from "../library/region.js";
+import type { CurrentPhysicalIssue } from "../protocol/read/observation.js";
 export type { RegionOverlap };
 export type Section<Value> = Readonly<{
     kind: "present";
@@ -31,7 +31,6 @@ export type ContractFleetAttachment = Readonly<{
     id: string;
     aliases: readonly AkumaAlias[];
 }>;
-export type { CurrentPhysicalIssue };
 export type ContractKanshiRow = ContractBoard["rows"][number] & Readonly<{
     phase: ContractPhase;
     holder: ContractHolderObservation;
@@ -98,3 +97,4 @@ export type KanshiReport = Readonly<{
     akuma: Section<AkumaKanshiWorld>;
     region?: Section<RegionRead>;
 }>;
+export type { CurrentPhysicalIssue };

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

@@ -2,7 +2,7 @@ import { type AliasBinding } from "../alias/index.js";
 import { type AkuId } from "../akuma/identity.js";
 import { contractId } from "../core/facts/types.js";
 import { type AkumaAlias, type AkumaGlob } from "../identity/selector.js";
-import type { WorldRoot } from "../world.js";
+import { type WorldRoot } from "../world.js";
 import type { KanshiReport, Section } from "../kanshi/index.js";
 import { type Repo } from "./repo.js";
 export type DirectAkumaSelector = AkuId | AkumaAlias;
@@ -17,6 +17,11 @@ export type AkumaSetAddressInput = Readonly<{
     akuma: readonly string[];
     repo?: Repo;
 }>;
+type UncheckedAkumaAddressInput = Readonly<{
+    path: unknown;
+    akuma: unknown;
+    repo?: unknown;
+}>;
 export type AkumaWorldScopeRefusal = Readonly<{
     kind: "akuma-not-in-world";
     ids: readonly AkuId[];
@@ -39,11 +44,12 @@ export type NamedAddressInput = Readonly<{
     aliases: Section<readonly AliasBinding[]>;
 }>;
 export declare function resolveNamedAddress(input: NamedAddressInput): NamedAddress;
-export declare function addressAkuma(input: AkumaAddressInput): Promise<Readonly<{
+export declare function addressAkuma(input: UncheckedAkumaAddressInput): Promise<Readonly<{
     path: WorldRoot;
     id: AkuId;
 }>>;
-export declare function addressAkumaSet(input: AkumaSetAddressInput): Promise<Readonly<{
+export declare function addressAkumaSet(input: UncheckedAkumaAddressInput): Promise<Readonly<{
     path: WorldRoot;
     ids: readonly AkuId[];
 }>>;
+export {};

package/build/src/library/address.js

@@ -5,6 +5,7 @@ import { parseAkuId } from "../akuma/identity.js";
 import { contractId } from "../core/facts/types.js";
 import { readDispatches } from "../dispatch/index.js";
 import { matchesAkumaGlob, parseAkumaAlias, parseAkumaGlob, } from "../identity/selector.js";
+import { World } from "../world.js";
 import { requireInput } from "./input.js";
 import { scopeForRepo } from "./repo.js";
 export class AkumaWorldScopeError extends TypeError {
@@ -72,7 +73,7 @@ export async function addressAkuma(input) {
     }
     if (values.repo !== undefined)
         scopeForRepo(values.repo);
-    const path = nonblank(values.path, "path");
+    const path = await World.prove(nonblank(values.path, "path"));
     return { path, id: await directId(path, nonblank(values.akuma, "akuma")) };
 }
 function idsFromFleet(fleet) {
@@ -143,7 +144,7 @@ export async function addressAkumaSet(input) {
     }
     if (!Array.isArray(values.akuma) || values.akuma.length === 0)
         throw new TypeError("akuma must be a nonempty selector array");
-    const path = nonblank(values.path, "path");
+    const path = await World.prove(nonblank(values.path, "path"));
     const selectors = values.akuma.map(parseSetSelector);
     if (hasSelectorKind(selectors, "contract") && values.repo === undefined) {
         throw new TypeError("Contract Akuma selector requires repo");

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

@@ -5,8 +5,9 @@ import type { AkuId } from "../akuma/identity.js";
 import { type Dispatch, type DispatchFailure } from "../dispatch/index.js";
 import { type AkumaAlias } from "../identity/selector.js";
 import type { Settings } from "../settings.js";
-import type { WorldRoot } from "../world.js";
+import { type WorldRoot } from "../world.js";
 import type { AllowedAction } from "../akuma/allowed.js";
+import { type ExecutionContext } from "../akuma/requests.js";
 import { type Keiyaku } from "./contract.js";
 import { type Repo } from "./repo.js";
 export type { AkumaStatus } from "../akuma/akuma.js";
@@ -98,7 +99,7 @@ export type ForkResult = Readonly<{
 }>> & Readonly<{
     parent: AkuId;
 }>);
-export declare function beginCall(input: CallInput): Promise<BornCall>;
+export declare function beginCall(input: CallInput, context: ExecutionContext): Promise<BornCall>;
 export declare function finishCall(born: BornCall, participantName?: string): Promise<CallResult>;
-export declare function callKeiyaku(input: CallInput): Promise<CallResult>;
+export declare function callKeiyaku(input: CallInput, execution?: ExecutionContext): Promise<CallResult>;
 export declare function forkKeiyaku(input: ForkInput): Promise<ForkResult>;

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

@@ -6,9 +6,12 @@ import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { publishDispatch, readDispatch } from "../dispatch/index.js";
 import { parseAkumaAlias } from "../identity/selector.js";
 import { readManagedWorktreeAppointment } from "../workspace-place.js";
+import { World } from "../world.js";
+import { localExecutionContext } from "../akuma/requests.js";
 import { requireInput } from "./input.js";
 import { addressAkuma } from "./address.js";
-import { KeiyakuRefused, seatForKeiyaku } from "./contract.js";
+import { KeiyakuRefused } from "./contract.js";
+import { seatForKeiyaku } from "./contract-handle.js";
 import { scopeForRepo } from "./repo.js";
 function nonblank(value, label) {
     if (typeof value !== "string" || value.trim().length === 0) {
@@ -36,10 +39,11 @@ function homeOption(value) {
         return undefined;
     return nonblank(value, "home");
 }
-function akumaWorld(path, home, settings) {
+function akumaWorld(path, home, settings, execution) {
     return Akuma.of(path, {
         ...(home === undefined ? {} : { home }),
         ...(settings === undefined ? {} : { settings }),
+        ...(execution === undefined ? {} : { execution }),
     });
 }
 function onlyKeys(values, allowed, label) {
@@ -151,6 +155,8 @@ async function resolveCallExecution(input) {
     }
     if (input.contract !== undefined) {
         const seat = seatForKeiyaku(input.contract);
+        if (seat === null)
+            throw new TypeError("contract must be a Keiyaku");
         const state = await currentManagedContract(input.contract, seat.id);
         const appointment = await readManagedWorktreeAppointment(seat.scope, state.id);
         if (appointment.kind === "unappointed") {
@@ -166,7 +172,7 @@ async function resolveCallExecution(input) {
     }
     return undefined;
 }
-export async function beginCall(input) {
+export async function beginCall(input, context) {
     const values = requireInput(input, "Keiyaku.call input");
     onlyKeys(values, [
         "path",
@@ -182,7 +188,7 @@ export async function beginCall(input) {
         "alias",
         "allowed",
     ], "Keiyaku.call input");
-    const path = nonblank(values.path, "path");
+    const path = await World.prove(nonblank(values.path, "path"));
     const archetype = nonblank(values.archetype, "archetype");
     const body = text(values.body, "body");
     const readonlyRequested = callReadonly(values.readonly);
@@ -192,13 +198,16 @@ export async function beginCall(input) {
     const home = homeOption(values.home);
     const settings = settingsOption(values.settings);
     const alias = values.alias === undefined ? undefined : parseAkumaAlias(nonblank(values.alias, "alias"));
-    const seat = values.contract === undefined ? undefined : seatForKeiyaku(values.contract);
+    const selectedSeat = values.contract === undefined ? undefined : seatForKeiyaku(values.contract);
+    if (values.contract !== undefined && selectedSeat === null)
+        throw new TypeError("contract must be a Keiyaku");
+    const seat = selectedSeat ?? undefined;
     const execution = await resolveCallExecution({
         path,
         ...(cwd === undefined ? {} : { cwd }),
         ...(seat === undefined ? {} : { contract: values.contract }),
     });
-    const world = akumaWorld(path, home, settings);
+    const world = akumaWorld(path, home, settings, context);
     const call = {
         archetype,
         body,
@@ -255,18 +264,15 @@ export async function finishCall(born, participantName) {
         observation,
     };
 }
-export async function callKeiyaku(input) {
-    return await finishCall(await beginCall(input));
+export async function callKeiyaku(input, execution = localExecutionContext()) {
+    return await finishCall(await beginCall(input, execution));
 }
 export async function forkKeiyaku(input) {
     const values = requireInput(input, "Keiyaku.fork input");
     onlyKeys(values, ["path", "akuma", "at", "repo"], "Keiyaku.fork input");
-    const path = nonblank(values.path, "path");
     const at = nonblank(values.at, "at");
-    const akuma = (await addressAkuma({
-        path,
-        akuma: nonblank(values.akuma, "akuma"),
-    })).id;
+    const addressed = await addressAkuma({ path: values.path, akuma: nonblank(values.akuma, "akuma") });
+    const { path, id: akuma } = addressed;
     const repository = values.repo === undefined ? undefined : scopeForRepo(values.repo);
     const receipt = await Akuma.of(path).of({ id: akuma }).fork({ at });
     if (receipt.kind !== "forked")

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

@@ -1,19 +1,27 @@
-import type { ContractId } from "../core/facts/types.js";
+import type { ActorId, ContractId } from "../core/facts/types.js";
 import { type AuditReport } from "../protocol/audit.js";
-import type { RepositoryScope } from "../protocol/operations.js";
+import { type RepositoryScope } from "../protocol/operations.js";
 import { type WorktreeHooks } from "./configuration.js";
 import { type MutationResult } from "./mutation.js";
 export type AuditInput = Readonly<{
-    actor?: string;
-    hooks?: WorktreeHooks;
     includeDirty?: boolean;
     showDiff?: boolean;
-    requireBranchesToBeUpToDate?: boolean;
     signal?: AbortSignal;
 }>;
+export type AuditOptions = Readonly<{
+    includeDirty: boolean;
+    showDiff: boolean;
+    signal?: AbortSignal;
+}>;
+export type AuditComposition = Readonly<{
+    actor?: ActorId;
+    hooks?: WorktreeHooks;
+    requireBranchesToBeUpToDate?: boolean;
+}>;
 /** Normalize public audit input and project the protocol audit operation. */
 export declare function auditContract(input: Readonly<{
     scope: RepositoryScope;
     contractId: ContractId;
-    input?: AuditInput;
+    input: AuditOptions;
+    composition?: AuditComposition;
 }>): Promise<MutationResult<AuditReport>>;

package/build/src/library/audit.js

@@ -1,44 +1,34 @@
 import { decodeContractDocument } from "../body/decode.js";
 import { withGitDecodeChannel } from "../git/read-observation.js";
 import { auditOperation } from "../protocol/audit.js";
+import { withScopeAbortSignal } from "../protocol/operations.js";
 import { worktreeHooksOption } from "./configuration.js";
-import { actorOption, documentDerivation, optionalBoolean, optionalSignal, requireInput } from "./input.js";
+import { documentDerivation } from "./input.js";
 import { completeMutation } from "./mutation.js";
 import { requireAccepted } from "./refusal.js";
-function normalizeAuditInput(input) {
-    const values = input === undefined ? undefined : requireInput(input, "audit input");
-    const signal = optionalSignal(values?.signal);
-    return {
-        hooks: worktreeHooksOption(values?.hooks),
-        ...actorOption(values?.actor),
-        includeDirty: optionalBoolean(values?.includeDirty, "includeDirty") ?? false,
-        showDiff: optionalBoolean(values?.showDiff, "showDiff") ?? false,
-        requireBranchesToBeUpToDate: optionalBoolean(values?.requireBranchesToBeUpToDate, "requireBranchesToBeUpToDate") ?? false,
-        ...(signal === undefined ? {} : { signal }),
-    };
-}
 /** Normalize public audit input and project the protocol audit operation. */
 export async function auditContract(input) {
-    const normalized = normalizeAuditInput(input.input);
-    return withGitDecodeChannel(input.scope, async (channel) => {
+    const composition = input.composition;
+    const scope = withScopeAbortSignal(input.scope, input.input.signal);
+    return withGitDecodeChannel(scope, async (channel) => {
         const accepted = requireAccepted(await auditOperation({
-            scope: input.scope,
+            scope,
             channel,
             contractId: input.contractId,
             deriveDocument: (state) => documentDerivation(decodeContractDocument(state.terms.document.bytes), state.terms.gates, state.id),
-            includeDirty: normalized.includeDirty,
-            showDiff: normalized.showDiff,
-            requireBranchesToBeUpToDate: normalized.requireBranchesToBeUpToDate,
-            ...(normalized.signal === undefined ? {} : { signal: normalized.signal }),
-            ...(normalized.actor === undefined ? {} : { actor: normalized.actor }),
+            includeDirty: input.input.includeDirty,
+            showDiff: input.input.showDiff,
+            requireBranchesToBeUpToDate: composition?.requireBranchesToBeUpToDate ?? false,
+            ...(input.input.signal === undefined ? {} : { signal: input.input.signal }),
+            ...(composition?.actor === undefined ? {} : { actor: composition.actor }),
         }));
         return completeMutation({
-            scope: input.scope,
+            scope,
             channel,
             contractId: input.contractId,
             accepted,
             value: (report) => report,
-            hooks: normalized.hooks,
+            hooks: composition?.hooks ?? worktreeHooksOption(undefined),
         });
     });
 }

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

@@ -3,9 +3,10 @@ import { type ArchetypeCatalogRow } from "../akuma/archetype.js";
 import type { TaskRow } from "../task/index.js";
 import { type ContractBoard } from "./contract.js";
 import { Repo } from "./repo.js";
-import type { WorldRoot } from "../world.js";
+import { type WorldRoot } from "../world.js";
 export type CatalogQuery = Readonly<{
     kind: "tasks";
+    namespace?: readonly string[];
 }> | Readonly<{
     kind: "contracts";
 }> | Readonly<{
@@ -52,6 +53,7 @@ export type Catalog = Readonly<{
     kind: "akuma";
     root: WorldRoot;
     archetype: string | null;
+    observedAt: string;
     rows: AkumaList["rows"];
     searched: readonly string[];
 }>;

package/build/src/library/catalog.js

@@ -1,9 +1,10 @@
 import { Akuma } from "../akuma/akuma.js";
 import { listArchetypeDefinitions } from "../akuma/archetype.js";
-import { observeTaskCatalogRows } from "../task/operations.js";
+import { observeTaskCatalogRows } from "../task/catalog.js";
 import { listKeiyaku } from "./contract.js";
 import { requireInput } from "./input.js";
 import { Repo } from "./repo.js";
+import { World } from "../world.js";
 function optionalHome(value) {
     if (value === undefined)
         return undefined;
@@ -12,10 +13,18 @@ function optionalHome(value) {
     }
     return value;
 }
-function worldRoot(value) {
+async function worldRoot(value) {
     if (typeof value !== "string" || value.trim().length === 0)
         throw new TypeError("path must be a WorldRoot");
-    return value;
+    return await World.prove(value);
+}
+function taskQueryValue(query) {
+    if (query.namespace !== undefined && !Array.isArray(query.namespace))
+        throw new TypeError("Keiyaku.ls Task namespace must be an array");
+    return {
+        kind: "tasks",
+        ...(query.namespace === undefined ? {} : { namespace: query.namespace }),
+    };
 }
 function queryValue(value) {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
@@ -26,10 +35,14 @@ function queryValue(value) {
         throw new TypeError("Keiyaku.ls query kind is invalid");
     }
     for (const key of Object.keys(query)) {
-        if (key !== "kind" && !(query.kind === "akuma" && key === "archetype")) {
+        if (key !== "kind" &&
+            !(query.kind === "akuma" && key === "archetype") &&
+            !(query.kind === "tasks" && key === "namespace")) {
             throw new TypeError(`Keiyaku.ls query has unknown field: ${key}`);
         }
     }
+    if (query.kind === "tasks")
+        return taskQueryValue(query);
     if (query.kind !== "akuma")
         return { kind: query.kind };
     if (query.archetype !== undefined && typeof query.archetype !== "string") {
@@ -62,15 +75,16 @@ export async function listCatalog(input) {
             rows: await listArchetypeDefinitions(home === undefined ? {} : { home }),
         };
     }
-    const path = worldRoot(values.path);
+    const path = await worldRoot(values.path);
     if (query.kind === "tasks") {
-        return { kind: "tasks", root: path, rows: await observeTaskCatalogRows(path) };
+        return { kind: "tasks", root: path, rows: await observeTaskCatalogRows(path, query.namespace) };
     }
     const listed = await Akuma.of(path).list(query.archetype === undefined ? undefined : { archetype: query.archetype });
     return {
         kind: "akuma",
         root: path,
         archetype: query.archetype ?? null,
+        observedAt: listed.observedAt,
         rows: listed.rows,
         searched: listed.searched,
     };