@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/src/git/workspace.js

@@ -0,0 +1,104 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { contractPhysicalName, gitObjectId, mintSnapshotId } from "./identity.js";
+import { runGit, runGitWithEnvironment } from "./repository.js";
+const WORKTREE_DIRECTORY = ["keiyaku", "wt"];
+export function deliveryWorktreePath(repository, contract) {
+    return resolve(repository.commonDirectory, ...WORKTREE_DIRECTORY, contractPhysicalName(contract));
+}
+export function withPrivateGitIndex(action) {
+    const directory = mkdtempSync(join(tmpdir(), "keiyaku-v4-index-"));
+    try {
+        return action({ GIT_INDEX_FILE: join(directory, "index") });
+    }
+    finally {
+        rmSync(directory, { recursive: true, force: true });
+    }
+}
+function fields(record, count) {
+    const result = [];
+    let start = 0;
+    while (result.length < count - 1) {
+        const separator = record.indexOf(" ", start);
+        if (separator < 0)
+            throw new Error(`malformed workspace status record: ${record}`);
+        result.push(record.slice(start, separator));
+        start = separator + 1;
+    }
+    result.push(record.slice(start));
+    return result;
+}
+function workspaceChanges(repository, workspace) {
+    const records = runGit(repository, [
+        "-C", workspace,
+        "status", "--porcelain=v2", "-z", "--untracked-files=all", "--ignore-submodules=none",
+    ]).toString("utf8").split("\0");
+    const staged = new Set();
+    const unstaged = new Set();
+    const untracked = new Set();
+    const submodules = new Set();
+    for (let index = 0; index < records.length - 1; index += 1) {
+        const record = records[index];
+        const kind = record[0];
+        if (kind === "?") {
+            untracked.add(fields(record, 2)[1]);
+            continue;
+        }
+        if (kind === "1" || kind === "2" || kind === "u") {
+            const parts = fields(record, kind === "1" ? 9 : kind === "2" ? 10 : 11);
+            const xy = parts[1];
+            const sub = parts[2];
+            const path = parts.at(-1);
+            if (xy[0] !== ".")
+                staged.add(path);
+            if (xy[1] !== ".")
+                unstaged.add(path);
+            if (sub.startsWith("S") && (sub[2] !== "." || sub[3] !== "."))
+                submodules.add(path);
+            if (kind === "2") {
+                const origin = records[index + 1];
+                if (origin === undefined)
+                    throw new Error("renamed workspace status record is missing its origin path");
+                if (xy[0] !== ".")
+                    staged.add(origin);
+                if (xy[1] !== ".")
+                    unstaged.add(origin);
+                index += 1;
+            }
+            continue;
+        }
+        throw new Error(`unknown workspace status record: ${record}`);
+    }
+    return {
+        staged: [...staged].sort(),
+        unstaged: [...unstaged].sort(),
+        untracked: [...untracked].sort(),
+        submodules: [...submodules].sort(),
+    };
+}
+/** Capture tracked and untracked workspace bytes without changing its real index. */
+export function captureWorkspaceTree(repository, workspace) {
+    const identities = runGit(repository, ["-C", workspace, "show", "-s", "--format=%H%n%T", "HEAD"])
+        .toString("utf8")
+        .split("\n");
+    if (identities.length !== 3 || identities[0] === undefined || identities[1] === undefined || identities[2] !== "") {
+        throw new Error("workspace HEAD/tree resolution did not return exactly two object IDs");
+    }
+    const head = mintSnapshotId(identities[0]);
+    const tree = gitObjectId(identities[1], "workspace tree");
+    const changes = workspaceChanges(repository, workspace);
+    const dirty = changes.staged.length > 0 || changes.unstaged.length > 0 || changes.untracked.length > 0;
+    if (!dirty)
+        return { tree, head, dirty, changes };
+    return withPrivateGitIndex((environment) => {
+        runGitWithEnvironment(repository, ["-C", workspace, "read-tree", "HEAD"], undefined, environment);
+        runGitWithEnvironment(repository, ["-C", workspace, "add", "--all"], undefined, environment);
+        return {
+            tree: gitObjectId(runGitWithEnvironment(repository, ["-C", workspace, "write-tree"], undefined, environment).toString("utf8").trim(), "workspace tree"),
+            head,
+            dirty,
+            changes,
+        };
+    });
+}

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

@@ -0,0 +1,9 @@
+export type IdentityFamily = "aku" | "kei" | "task" | "resp";
+export declare function identityCoordinate(input: Readonly<{
+    family: IdentityFamily;
+    segments: readonly string[];
+}>): string;
+export declare function identitySegments(input: Readonly<{
+    family: IdentityFamily;
+    value: string;
+}>): readonly string[];

package/build/src/identity/coordinates.js

@@ -0,0 +1,20 @@
+function prefix(family) { return `${family}/`; }
+function validSegment(segment) {
+    return segment.length > 0 && !/[\/\s\p{Cc}]/u.test(segment);
+}
+export function identityCoordinate(input) {
+    if (input.segments.length === 0 || !input.segments.every(validSegment)) {
+        throw new TypeError("identity coordinate requires nonempty segments");
+    }
+    return `${prefix(input.family)}${input.segments.join("/")}`;
+}
+export function identitySegments(input) {
+    const marker = prefix(input.family);
+    if (!input.value.startsWith(marker))
+        throw new TypeError(`identity must use ${marker}`);
+    const segments = input.value.slice(marker.length).split("/");
+    if (segments.length === 0 || !segments.every(validSegment)) {
+        throw new TypeError("identity coordinate contains an invalid segment");
+    }
+    return segments;
+}

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

@@ -0,0 +1,8 @@
+export declare function normalizeIdentityStem(input: Readonly<{
+    source: string;
+}>): string;
+export declare function fitIdentityStem(input: Readonly<{
+    stem: string;
+    maxBytes: number;
+    suffix?: string;
+}>): string;

package/build/src/identity/normalize.js

@@ -0,0 +1,45 @@
+const GRAPHEMES = new Intl.Segmenter("und", { granularity: "grapheme" });
+const WORD_GRAPHEME = /^[\p{Letter}\p{Number}\p{Mark}]+$/u;
+const EMOJI_GRAPHEME = new RegExp("^\\p{RGI_Emoji}$", "v");
+const SUFFIX = /^[\p{Letter}\p{Number}]+$/u;
+function graphemes(value) {
+    return [...GRAPHEMES.segment(value)].map(({ segment }) => segment);
+}
+export function normalizeIdentityStem(input) {
+    const source = input.source.normalize("NFKC").toLowerCase().normalize("NFKC");
+    let result = "";
+    let separator = false;
+    for (const segment of graphemes(source)) {
+        if (!WORD_GRAPHEME.test(segment) && !EMOJI_GRAPHEME.test(segment)) {
+            separator ||= result.length > 0;
+            continue;
+        }
+        if (separator)
+            result += "-";
+        result += segment;
+        separator = false;
+    }
+    return result;
+}
+export function fitIdentityStem(input) {
+    if (!Number.isSafeInteger(input.maxBytes) || input.maxBytes < 1) {
+        throw new Error("identity stem byte budget must be a positive safe integer");
+    }
+    if (input.suffix !== undefined && !SUFFIX.test(input.suffix)) {
+        throw new Error("identity suffix must contain only letters or numbers");
+    }
+    const suffix = input.suffix === undefined ? "" : `-${input.suffix}`;
+    const budget = input.maxBytes - Buffer.byteLength(suffix);
+    if (budget < 1)
+        throw new Error("identity stem byte budget cannot contain its suffix");
+    let stem = "";
+    for (const segment of graphemes(input.stem)) {
+        if (Buffer.byteLength(stem + segment) > budget)
+            break;
+        stem += segment;
+    }
+    stem = stem.replace(/-+$/u, "");
+    if (stem.length === 0)
+        throw new Error("identity stem is empty after fitting");
+    return stem + suffix;
+}

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

@@ -0,0 +1,12 @@
+declare const AKUMA_ALIAS: unique symbol;
+declare const AKUMA_GLOB: unique symbol;
+export type AkumaAlias = string & {
+    readonly [AKUMA_ALIAS]: true;
+};
+export type AkumaGlob = string & {
+    readonly [AKUMA_GLOB]: true;
+};
+export declare function parseAkumaAlias(value: string): AkumaAlias;
+export declare function parseAkumaGlob(value: string): AkumaGlob;
+export declare function matchesAkumaGlob(glob: AkumaGlob, value: string): boolean;
+export {};

package/build/src/identity/selector.js

@@ -0,0 +1,26 @@
+const AKUMA_ALIAS_PATTERN = /^@[a-z][a-z0-9-]{0,63}$/u;
+const AKUMA_GLOB_SUFFIX = /^[0-9a-f*]+$/u;
+export function parseAkumaAlias(value) {
+    if (!AKUMA_ALIAS_PATTERN.test(value)) {
+        throw new TypeError("Akuma alias must match ^@[a-z][a-z0-9-]{0,63}$");
+    }
+    return value;
+}
+export function parseAkumaGlob(value) {
+    const segments = value.split("/");
+    const archetype = segments[1] ?? "";
+    const archetypeProbe = archetype.replaceAll("*", "x");
+    if (segments.length !== 3 || segments[0] !== "aku" || !value.includes("*")
+        || archetype.length === 0 || normalizeIdentityStem({ source: archetypeProbe }) !== archetypeProbe
+        || !AKUMA_GLOB_SUFFIX.test(segments[2] ?? "")) {
+        throw new TypeError("Akuma glob must be aku/<archetype-pattern>/<hex-pattern> and contain *");
+    }
+    return value;
+}
+export function matchesAkumaGlob(glob, value) {
+    const pattern = parseAkumaGlob(glob)
+        .replaceAll(/[.+?^${}()|[\]\\]/gu, "\\$&")
+        .replaceAll("*", "[^/]*");
+    return new RegExp(`^${pattern}$`, "u").test(value);
+}
+import { normalizeIdentityStem } from "./normalize.js";

package/build/src/index.d.ts

@@ -0,0 +1,6 @@
+export { AuthorityCorruptionError, Delivery, gatesFrom, Keiyaku, KeiyakuRefused, KeiyakuRetry, NoGitWorldError, Repo, requireBranchesToBeUpToDateFrom, SettingsError, worktreeHooksFrom } from "./library/keiyaku.js";
+export { settings } from "./settings.js";
+export { World, WorldError } from "./world.js";
+export type { WorldRoot } from "./world.js";
+export type { Settings, SettingsEntry, SettingsInput, SettingsNamespaceFailure, SettingsNamespaceView, SettingsScope, SettingsScopeState, } from "./settings.js";
+export type { AttestationVerdict, AbandonInput, ActorId, AkuId, AkumaAddressInput, AkumaAlias, AkumaGlob, AkumaHistoryInput, AkumaHistoryResult, AkumaInterruptInput, AkumaInterruptResult, AkumaKillResult, AkumaSetAddressInput, AkumaStatus, AkumaStatusView, AkumaTellInput, AkumaTellResult, AkumaWaitInput, AkumaWaitResult, AliasBinding, AliasStage, AmendResult, AmendInput, ArcInput, AuditReport, BindInput, BindResult, CallInput, CallObservation, CallResult, Catalog, CatalogInput, CatalogQuery, ChangeId, ContractId, ContractState, ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractListInput, ContractObservation, ContractObservationInput, ContractPhase, ContractRow, DeliverInput, Fact, FactKind, Dispatch, DispatchFailure, DispatchStage, DirectAkumaSelector, Gate, GatesFromInput, HookCommand, RequireBranchesToBeUpToDateFromInput, KeiyakuOfInput, KeiyakuRefusal, KeiyakuRetryReason, ForkInput, ForkResult, IntegrationFailure, Lag, MutationResult, PlacementStop, RegionOverlap, ReconcileInput, RepoReconcileReport, Review, ReconcileReport, ReviewInput, RepoAtInput, AuditInput, SnapshotId, SettlementAction, SettlementLag, SettlementReport, SetAkumaSelector, TaskId, TimelineEntry, TopologyEffect, VerificationStop, WorktreeHooks, } from "./library/keiyaku.js";

package/build/src/index.js

@@ -0,0 +1,3 @@
+export { AuthorityCorruptionError, Delivery, gatesFrom, Keiyaku, KeiyakuRefused, KeiyakuRetry, NoGitWorldError, Repo, requireBranchesToBeUpToDateFrom, SettingsError, worktreeHooksFrom } from "./library/keiyaku.js";
+export { settings } from "./settings.js";
+export { World, WorldError } from "./world.js";

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

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

package/build/src/kanshi/index.js

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

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

@@ -0,0 +1,8 @@
+import { Repo } from "../library/repo.js";
+import type { KanshiReport } from "./report.js";
+import type { WorldRoot } from "../world.js";
+export type KanshiInput = Readonly<{
+    world: WorldRoot | null;
+    repo?: Repo;
+}>;
+export declare function kanshi(input: KanshiInput): Promise<KanshiReport>;

package/build/src/kanshi/read.js

@@ -0,0 +1,209 @@
+import { Repo } from "../library/repo.js";
+import { scopeForRepo } from "../library/repo.js";
+import { observeTaskStatusRows } from "../task/operations.js";
+import { Akuma } from "../akuma/index.js";
+import { readAliases } from "../alias/index.js";
+import { readDispatchesAt } from "../dispatch/index.js";
+import { readTaskHolderProjectionAt } from "../settlement/holder.js";
+import { readContractBoard } from "../protocol/read/status.js";
+import { withGitDecodeChannel, withGitReadObservation } from "../git/read-observation.js";
+function diagnostic(error) {
+    let source;
+    if (error instanceof Error)
+        source = error.message;
+    else if (typeof error === "object" && error !== null) {
+        try {
+            source = JSON.stringify(error);
+        }
+        catch {
+            source = String(error);
+        }
+    }
+    else
+        source = String(error);
+    const line = source.replaceAll(/\s+/gu, " ").trim();
+    return line.length <= 240 ? line : `${line.slice(0, 239)}…`;
+}
+function coordinate(input) {
+    if (typeof input !== "object" || input === null || Array.isArray(input))
+        throw new TypeError("kanshi input must be an object");
+    for (const key of Object.keys(input))
+        if (key !== "world" && key !== "repo")
+            throw new TypeError(`kanshi input has unknown field: ${key}`);
+    if (input.world !== null && (typeof input.world !== "string" || input.world.trim().length === 0)) {
+        throw new TypeError("kanshi world must be a WorldRoot or null");
+    }
+    if (input.repo !== undefined && !(input.repo instanceof Repo))
+        throw new TypeError("kanshi repo must be a Repo");
+    return input;
+}
+async function readBranch(repo) {
+    if (repo === undefined)
+        return null;
+    try {
+        return await repo.currentBranch();
+    }
+    catch {
+        return null;
+    }
+}
+async function readContracts(observation) {
+    try {
+        return { kind: "present", value: await readContractBoard(observation) };
+    }
+    catch (error) {
+        return { kind: "failed", failure: { message: diagnostic(error) } };
+    }
+}
+async function readHolders(observation) {
+    try {
+        return { kind: "present", value: await readTaskHolderProjectionAt(observation) };
+    }
+    catch (error) {
+        return { kind: "failed", failure: { message: diagnostic(error) } };
+    }
+}
+function decorateContracts(contracts, holders) {
+    if (contracts.kind !== "present")
+        return contracts;
+    return {
+        kind: "present",
+        value: {
+            ...contracts.value,
+            rows: contracts.value.rows.map((row) => {
+                if (holders.kind === "failed")
+                    return { ...row, holder: { kind: "unavailable" } };
+                const holder = holders.kind === "present" ? holders.value.get(row.id) : undefined;
+                return holder?.disposition === "held"
+                    ? { ...row, holder: { kind: "held", taskId: holder.taskId } }
+                    : { ...row, holder: { kind: "none" } };
+            }),
+        },
+    };
+}
+function contractEndpointObserver(contracts) {
+    const dispositions = contracts.kind === "present"
+        ? new Map(contracts.value.rows.map((row) => [row.id, row.disposition]))
+        : null;
+    return (id) => dispositions === null ? "unavailable" : dispositions.get(id) ?? "missing";
+}
+function joinTasks(rows, holders, observeContract) {
+    const associations = new Map(holders.kind === "present"
+        ? [...holders.value.values()]
+            .filter((holder) => holder.disposition === "held")
+            .map((holder) => [holder.taskId, holder.contractId])
+        : []);
+    return rows.map((row) => {
+        const contractId = associations.get(row.id);
+        if (contractId === undefined)
+            return row;
+        return { ...row, contract: { id: contractId, observed: observeContract(contractId) } };
+    });
+}
+function readTasks(path, holders, observeContract) {
+    if (holders.kind === "failed")
+        return { kind: "failed", failure: holders.failure };
+    try {
+        return {
+            kind: "present",
+            value: { root: path, rows: joinTasks(observeTaskStatusRows(path), holders, observeContract) },
+        };
+    }
+    catch (error) {
+        return { kind: "failed", failure: { message: diagnostic(error) } };
+    }
+}
+function joinAkuma(path, observeContract, dispatches) {
+    try {
+        const source = Akuma.of(path).list();
+        const aliases = readAliases(path);
+        const aliasById = new Map();
+        for (const binding of aliases)
+            aliasById.set(binding.akuId, [...(aliasById.get(binding.akuId) ?? []), binding]);
+        const dispatchById = new Map(dispatches.map((dispatch) => [dispatch.akuId, dispatch]));
+        return {
+            kind: "present",
+            value: {
+                ...source,
+                rows: source.rows.map((row) => {
+                    const dispatch = dispatchById.get(row.id);
+                    return {
+                        ...row,
+                        aliases: (aliasById.get(row.id) ?? []).map((binding) => binding.alias),
+                        ...(dispatch === undefined ? {} : {
+                            contract: {
+                                id: dispatch.contractId,
+                                observed: observeContract(dispatch.contractId),
+                            },
+                        }),
+                    };
+                }),
+            },
+        };
+    }
+    catch (error) {
+        return { kind: "failed", failure: { message: diagnostic(error) } };
+    }
+}
+async function readDispatches(observation) {
+    try {
+        return { kind: "present", value: await readDispatchesAt(observation) };
+    }
+    catch (error) {
+        return { kind: "failed", failure: { message: diagnostic(error) } };
+    }
+}
+export async function kanshi(input) {
+    const observedAt = new Date().toISOString();
+    const { world, repo } = coordinate(input);
+    const branch = await readBranch(repo);
+    if (repo === undefined) {
+        const contracts = { kind: "absent" };
+        const holders = { kind: "absent" };
+        const observeContract = contractEndpointObserver(contracts);
+        return {
+            root: world,
+            observedAt,
+            branch,
+            contracts,
+            tasks: world === null ? { kind: "absent" } : readTasks(world, holders, observeContract),
+            akuma: world === null ? { kind: "absent" } : joinAkuma(world, observeContract, []),
+        };
+    }
+    try {
+        const repository = scopeForRepo(repo);
+        return await withGitDecodeChannel(repository, (channel) => withGitReadObservation(repository, channel, async (observation) => {
+            const [contractSection, holders, dispatches] = await Promise.all([
+                readContracts(observation),
+                readHolders(observation),
+                readDispatches(observation),
+            ]);
+            const contracts = decorateContracts(contractSection, holders);
+            const observeContract = contractEndpointObserver(contracts);
+            const tasks = world === null ? { kind: "absent" } : readTasks(world, holders, observeContract);
+            return {
+                root: world,
+                observedAt,
+                branch,
+                contracts,
+                tasks,
+                akuma: world === null
+                    ? { kind: "absent" }
+                    : dispatches.kind === "failed"
+                        ? dispatches
+                        : joinAkuma(world, observeContract, dispatches.value),
+            };
+        }));
+    }
+    catch (error) {
+        const failure = { kind: "failed", failure: { message: diagnostic(error) } };
+        return {
+            root: world,
+            observedAt,
+            branch,
+            contracts: failure,
+            tasks: world === null ? { kind: "absent" } : failure,
+            akuma: world === null ? { kind: "absent" } : failure,
+        };
+    }
+}

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

@@ -0,0 +1,60 @@
+import type { ContractBoard, ContractDisposition } from "../library/contract.js";
+import type { TaskId, TaskRef, TaskRow } from "../task/index.js";
+import type { AkumaList, AkumaListRow, UnbornAkumaListRow } from "../akuma/index.js";
+import type { AkumaAlias } from "../identity/selector.js";
+import type { WorldRoot } from "../world.js";
+export type Section<Value> = Readonly<{
+    kind: "present";
+    value: Value;
+}> | Readonly<{
+    kind: "absent";
+}> | Readonly<{
+    kind: "failed";
+    failure: Readonly<{
+        message: string;
+    }>;
+}>;
+export type ContractEndpointObservation = ContractDisposition | "missing" | "unavailable";
+export type ContractHolderObservation = Readonly<{
+    kind: "held";
+    taskId: TaskId;
+}> | Readonly<{
+    kind: "none";
+}> | Readonly<{
+    kind: "unavailable";
+}>;
+export type ContractKanshiRow = ContractBoard["rows"][number] & Readonly<{
+    holder: ContractHolderObservation;
+}>;
+export type ContractKanshiBoard = Omit<ContractBoard, "rows"> & Readonly<{
+    rows: readonly ContractKanshiRow[];
+}>;
+export type TaskKanshiRow = TaskRow & Readonly<{
+    contract?: Readonly<{
+        id: string;
+        observed: ContractEndpointObservation;
+    }>;
+    blockers?: readonly TaskRef[];
+}>;
+export type TaskKanshiWorld = Readonly<{
+    root: WorldRoot;
+    rows: readonly TaskKanshiRow[];
+}>;
+export type AkumaKanshiRow = (AkumaListRow | UnbornAkumaListRow) & Readonly<{
+    aliases: readonly AkumaAlias[];
+    contract?: Readonly<{
+        id: string;
+        observed: ContractEndpointObservation;
+    }>;
+}>;
+export type AkumaKanshiWorld = Omit<AkumaList, "rows"> & Readonly<{
+    rows: readonly AkumaKanshiRow[];
+}>;
+export type KanshiReport = Readonly<{
+    root: WorldRoot | null;
+    observedAt: string;
+    branch: string | null;
+    contracts: Section<ContractKanshiBoard>;
+    tasks: Section<TaskKanshiWorld>;
+    akuma: Section<AkumaKanshiWorld>;
+}>;

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

@@ -0,0 +1,8 @@
+import type { KanshiReport } from "./report.js";
+export type KanshiSelection = Readonly<{
+    contract: string;
+}>;
+export declare function selectKanshi(input: Readonly<{
+    report: KanshiReport;
+    contract: string;
+}>): KanshiReport;

package/build/src/kanshi/select.js

@@ -0,0 +1,21 @@
+export function selectKanshi(input) {
+    const { report, contract } = input;
+    return {
+        ...report,
+        contracts: report.contracts.kind === "present"
+            ? { kind: "present", value: { ...report.contracts.value, rows: report.contracts.value.rows.filter((row) => row.id === contract) } }
+            : report.contracts,
+        tasks: report.tasks.kind === "present"
+            ? { kind: "present", value: { ...report.tasks.value, rows: report.tasks.value.rows.filter((row) => row.contract?.id === contract) } }
+            : report.tasks,
+        akuma: report.akuma.kind === "present"
+            ? {
+                kind: "present",
+                value: {
+                    ...report.akuma.value,
+                    rows: report.akuma.value.rows.filter((row) => row.contract?.id === contract),
+                },
+            }
+            : report.akuma,
+    };
+}

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

@@ -0,0 +1,48 @@
+import { type AkuId } from "../akuma/identity.js";
+import { type AkumaAlias, type AkumaGlob } from "../identity/selector.js";
+import type { Settings } from "../settings.js";
+import type { WorldRoot } from "../world.js";
+import { type Repo } from "./repo.js";
+export type DirectAkumaSelector = AkuId | AkumaAlias;
+export type SetAkumaSelector = DirectAkumaSelector | AkumaGlob | `kei/${string}`;
+export type AkumaAddressInput = Readonly<{
+    path: WorldRoot;
+    akuma: string;
+    settings?: Settings;
+    repo?: Repo;
+}>;
+export type AkumaSetAddressInput = Readonly<{
+    path: WorldRoot;
+    akuma: readonly string[];
+    settings?: Settings;
+    repo?: Repo;
+}>;
+export type NamedAddressContract = Readonly<{
+    id: string;
+    disposition: "active" | "terminal";
+    workspace: "worktree" | "here";
+    worktreePath: string | null;
+}>;
+export type NamedAddress = Readonly<{
+    kind: "contract";
+    id: string;
+}> | Readonly<{
+    kind: "akuma";
+    id: AkuId;
+}>;
+export type NamedAddressInput = Readonly<{
+    path: WorldRoot | null;
+    selector: string;
+    contracts: readonly NamedAddressContract[];
+}>;
+export declare function resolveNamedAddress(input: NamedAddressInput): NamedAddress;
+export declare function addressAkuma(input: AkumaAddressInput): Readonly<{
+    path: WorldRoot;
+    id: AkuId;
+    settings?: Settings;
+}>;
+export declare function addressAkumaSet(input: AkumaSetAddressInput): Promise<Readonly<{
+    path: WorldRoot;
+    ids: readonly AkuId[];
+    settings?: Settings;
+}>>;