@astrosheep/keiyaku 2.9.12 → 4.0.0

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,6 @@
+declare const AKUMA_ALIAS: unique symbol;
+export type AkumaAlias = string & {
+    readonly [AKUMA_ALIAS]: true;
+};
+export declare function parseAkumaAlias(value: string): AkumaAlias;
+export {};

package/build/src/identity/selector.js

@@ -0,0 +1,7 @@
+const AKUMA_ALIAS_PATTERN = /^@[a-z][a-z0-9-]{0,63}$/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;
+}

package/build/src/index.d.ts

@@ -0,0 +1,4 @@
+export { AuthorityCorruptionError, Delivery, gatesFrom, Keiyaku, KeiyakuRefused, KeiyakuRetry, NoGitWorldError, Repo, SettingsError, worktreeHooksFrom } from "./library/keiyaku.js";
+export { settings } from "./settings.js";
+export type { Settings, SettingsEntry, SettingsInput, SettingsNamespaceFailure, SettingsNamespaceView, SettingsScope, SettingsScopeState, } from "./settings.js";
+export type { AttestationVerdict, AbandonInput, ActorId, AkuId, AkumaAlias, AkumaStatus, AliasBinding, AliasStage, AmendResult, AmendInput, ArcInput, AuditReport, BindInput, BindResult, CallInput, CallObservation, CallResult, ChangeId, ContractId, ContractState, ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractListInput, ContractObservation, ContractObservationInput, ContractPhase, ContractRow, DeliverInput, Fact, FactKind, Dispatch, DispatchFailure, DispatchStage, Gate, GatesFromInput, HookCommand, KeiyakuOfInput, KeiyakuRefusal, KeiyakuRetryReason, ForkInput, ForkResult, IntegrationFailure, Lag, MutationResult, PlacementStop, RegionOverlap, ReconcileInput, RepoReconcileReport, Review, ReconcileReport, ReviewInput, RepoAtInput, AuditInput, SnapshotId, SettlementAction, SettlementLag, SettlementReport, TaskId, TimelineEntry, TopologyEffect, VerificationStop, WorktreeHooks, WorktreeHooksFromInput, } from "./library/keiyaku.js";

package/build/src/index.js

@@ -0,0 +1,2 @@
+export { AuthorityCorruptionError, Delivery, gatesFrom, Keiyaku, KeiyakuRefused, KeiyakuRetry, NoGitWorldError, Repo, SettingsError, worktreeHooksFrom } from "./library/keiyaku.js";
+export { settings } from "./settings.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, 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,5 @@
+import type { KanshiReport } from "./report.js";
+export type KanshiInput = Readonly<{
+    path?: string;
+}>;
+export declare function kanshi(input?: KanshiInput): Promise<KanshiReport>;

package/build/src/kanshi/read.js

@@ -0,0 +1,100 @@
+import { resolve } from "node:path";
+import { listKeiyaku, taskHoldersForRepo } from "../library/contract.js";
+import { NoGitWorldError, Repo } from "../library/repo.js";
+import { Tasks } from "../task/index.js";
+import { Akuma } from "../akuma/index.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 (input === undefined)
+        return process.cwd();
+    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 !== "path")
+            throw new TypeError(`kanshi input has unknown field: ${key}`);
+    if (input.path === undefined)
+        return process.cwd();
+    if (typeof input.path !== "string" || input.path.trim().length === 0)
+        throw new TypeError("kanshi path must be a nonblank string");
+    return input.path;
+}
+async function readContracts(path) {
+    try {
+        const repo = Repo.at({ path });
+        try {
+            return { repo, section: { kind: "present", value: await listKeiyaku({ repo }) } };
+        }
+        catch (error) {
+            return { repo, section: { kind: "failed", failure: { message: diagnostic(error) } } };
+        }
+    }
+    catch (error) {
+        return { section: error instanceof NoGitWorldError
+                ? { kind: "absent" }
+                : { kind: "failed", failure: { message: diagnostic(error) } } };
+    }
+}
+function joinTasks(rows, holders, contracts) {
+    const dispositions = contracts.kind === "present"
+        ? new Map(contracts.value.rows.map((row) => [row.id, row.disposition]))
+        : null;
+    const associations = new Map(holders
+        .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;
+        const observed = contracts.kind !== "present"
+            ? "unavailable"
+            : dispositions?.get(contractId) ?? "missing";
+        return { ...row, contract: { id: contractId, observed } };
+    });
+}
+async function readTasks(path, contracts, repo) {
+    try {
+        const tasks = Tasks.at({ path });
+        const result = await tasks.list({ selection: "all", scope: "world" });
+        if (result.kind !== "accepted")
+            return { kind: "failed", failure: { message: diagnostic(result) } };
+        return {
+            kind: "present",
+            value: { root: tasks.root, rows: joinTasks(result.value, repo === undefined ? [] : taskHoldersForRepo(repo), contracts) },
+        };
+    }
+    catch (error) {
+        return { kind: "failed", failure: { message: diagnostic(error) } };
+    }
+}
+function readAkuma(path) {
+    try {
+        const source = Akuma.at({ path }).list();
+        return { kind: "present", value: source };
+    }
+    catch (error) {
+        return { kind: "failed", failure: { message: diagnostic(error) } };
+    }
+}
+export async function kanshi(input) {
+    const path = resolve(coordinate(input));
+    const contractRead = await readContracts(path);
+    const contracts = contractRead.section;
+    const tasks = await readTasks(path, contracts, contractRead.repo);
+    return { root: path, contracts, tasks, akuma: readAkuma(path) };
+}

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

@@ -0,0 +1,35 @@
+import type { ContractBoard, ContractDisposition } from "../index.js";
+import type { TaskRow } from "../task/index.js";
+import type { AkumaList, AkumaListRow, UnbornAkumaListRow } from "../akuma/index.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 TaskKanshiRow = TaskRow & Readonly<{
+    contract?: Readonly<{
+        id: string;
+        observed: ContractEndpointObservation;
+    }>;
+}>;
+export type TaskKanshiWorld = Readonly<{
+    root: string;
+    rows: readonly TaskKanshiRow[];
+}>;
+export type AkumaKanshiRow = AkumaListRow | UnbornAkumaListRow;
+export type AkumaKanshiWorld = Omit<AkumaList, "rows"> & Readonly<{
+    rows: readonly AkumaKanshiRow[];
+}>;
+export type KanshiReport = Readonly<{
+    root: string;
+    contracts: Section<ContractBoard>;
+    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,
+    };
+}

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

@@ -0,0 +1,79 @@
+import { type AliasBinding } from "../alias/index.js";
+import { type AkumaStatus, type ForkReceipt } from "../akuma/akuma.js";
+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 Keiyaku } from "./contract.js";
+import { type Repo } from "./repo.js";
+export type { AkumaStatus } from "../akuma/akuma.js";
+export type IntegrationFailure = Readonly<{
+    kind: "authority-corruption" | "infrastructure";
+    diagnostic: string;
+}>;
+export type DispatchStage = Readonly<{
+    kind: "none";
+}> | Readonly<{
+    kind: "dispatched";
+    dispatch: Dispatch;
+}> | Readonly<{
+    kind: "failed";
+    failure: DispatchFailure | IntegrationFailure;
+}>;
+export type AliasStage = Readonly<{
+    kind: "none";
+}> | Readonly<{
+    kind: "aliased";
+    alias: AliasBinding;
+    previous: AkuId | null;
+}> | Readonly<{
+    kind: "skipped";
+    reason: "dispatch-failed";
+}> | Readonly<{
+    kind: "failed";
+    failure: IntegrationFailure;
+}>;
+export type CallInput = Readonly<{
+    path: string;
+    archetype: string;
+    body: string;
+    cwd?: string;
+    mode?: "wait" | "detach";
+    timeoutMs?: number;
+    settings?: Settings;
+    contract?: Keiyaku;
+    alias?: AkumaAlias;
+}>;
+export type CallObservation = Readonly<{
+    kind: "detached";
+}> | Readonly<{
+    kind: "observed";
+    status: AkumaStatus;
+}> | Readonly<{
+    kind: "failed";
+    failure: IntegrationFailure;
+}>;
+export type CallResult = Readonly<{
+    kind: "called";
+    akuma: AkuId;
+    dispatch: DispatchStage;
+    alias: AliasStage;
+    observation: CallObservation;
+}>;
+export type ForkInput = Readonly<{
+    path: string;
+    akuma: AkuId;
+    at: string;
+    settings?: Settings;
+    repo?: Repo;
+}>;
+export type ForkResult = Readonly<{
+    kind: "forked";
+    child: AkuId;
+    dispatch: DispatchStage;
+}> | Exclude<ForkReceipt, Readonly<{
+    kind: "forked";
+    child: AkuId;
+}>>;
+export declare function callKeiyaku(input: CallInput): Promise<CallResult>;
+export declare function forkKeiyaku(input: ForkInput): Promise<ForkResult>;

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

@@ -0,0 +1,151 @@
+import { resolve } from "node:path";
+import { moveAlias } from "../alias/index.js";
+import { Akuma } from "../akuma/akuma.js";
+import { parseAkuId } from "../akuma/identity.js";
+import { AuthorityCorruptionError } from "../core/facts/errors.js";
+import { publishDispatch, readDispatch, } from "../dispatch/index.js";
+import { parseAkumaAlias } from "../identity/selector.js";
+import { requireInput } from "./input.js";
+import { seatForKeiyaku } from "./contract.js";
+import { scopeForRepo } from "./repo.js";
+function nonblank(value, label) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new TypeError(`${label} must be a nonblank string`);
+    }
+    return value;
+}
+function text(value, label) {
+    if (typeof value !== "string")
+        throw new TypeError(`${label} must be a string`);
+    return value;
+}
+function settingsOption(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "object" || value === null || typeof value.namespace !== "function") {
+        throw new TypeError("settings must be a Settings");
+    }
+    return value;
+}
+function onlyKeys(values, allowed, label) {
+    const accepted = new Set(allowed);
+    for (const key of Object.keys(values)) {
+        if (!accepted.has(key))
+            throw new TypeError(`${label} has unknown field: ${key}`);
+    }
+}
+function integrationFailure(error) {
+    return {
+        kind: error instanceof AuthorityCorruptionError ? "authority-corruption" : "infrastructure",
+        diagnostic: error instanceof Error ? error.message : String(error),
+    };
+}
+function callMode(value) {
+    if (value === undefined || value === "wait")
+        return "wait";
+    if (value === "detach")
+        return "detach";
+    throw new TypeError("mode must be wait or detach");
+}
+function callTimeout(value, mode) {
+    if (mode === "detach" && value !== undefined) {
+        throw new TypeError("timeoutMs is not valid in detach mode");
+    }
+    if (value === undefined)
+        return 300_000;
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+        throw new TypeError("timeoutMs must be a nonnegative finite number");
+    }
+    return value;
+}
+async function observeCall(handle, mode, timeoutMs) {
+    if (mode === "detach")
+        return { kind: "detached" };
+    try {
+        return { kind: "observed", status: await handle.wait(undefined, { timeoutMs }) };
+    }
+    catch (error) {
+        return { kind: "failed", failure: integrationFailure(error) };
+    }
+}
+function dispatchStage(input) {
+    try {
+        const published = publishDispatch(input);
+        return published.kind === "dispatched"
+            ? { kind: "dispatched", dispatch: published.dispatch }
+            : { kind: "failed", failure: published.failure };
+    }
+    catch (error) {
+        return { kind: "failed", failure: integrationFailure(error) };
+    }
+}
+function forkDispatchStage(input) {
+    try {
+        const parent = readDispatch(input.repository, input.parent);
+        return parent === null
+            ? { kind: "none" }
+            : dispatchStage({ repository: input.repository, akuId: input.child, contractId: parent.contractId });
+    }
+    catch (error) {
+        return { kind: "failed", failure: integrationFailure(error) };
+    }
+}
+export async function callKeiyaku(input) {
+    const values = requireInput(input, "Keiyaku.call input");
+    onlyKeys(values, ["path", "archetype", "body", "cwd", "mode", "timeoutMs", "settings", "contract", "alias"], "Keiyaku.call input");
+    const path = resolve(nonblank(values.path, "path"));
+    const archetype = nonblank(values.archetype, "archetype");
+    const body = text(values.body, "body");
+    const cwd = values.cwd === undefined ? undefined : nonblank(values.cwd, "cwd");
+    const mode = callMode(values.mode);
+    const timeoutMs = callTimeout(values.timeoutMs, mode);
+    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 handle = await Akuma.at({ path, ...(settings === undefined ? {} : { settings }) }).call({
+        archetype,
+        body,
+        ...(cwd === undefined ? {} : { cwd }),
+    });
+    const dispatch = seat === undefined
+        ? { kind: "none" }
+        : dispatchStage({ repository: seat.scope, akuId: handle.id, contractId: seat.id });
+    let aliasStage = { kind: "none" };
+    if (alias !== undefined) {
+        if (dispatch.kind === "failed")
+            aliasStage = { kind: "skipped", reason: "dispatch-failed" };
+        else {
+            try {
+                const moved = await moveAlias({ world: path, alias, akuId: handle.id });
+                aliasStage = { kind: "aliased", alias: moved.alias, previous: moved.previous };
+            }
+            catch (error) {
+                aliasStage = { kind: "failed", failure: integrationFailure(error) };
+            }
+        }
+    }
+    const observation = await observeCall(handle, mode, timeoutMs);
+    return { kind: "called", akuma: handle.id, dispatch, alias: aliasStage, observation };
+}
+export async function forkKeiyaku(input) {
+    const values = requireInput(input, "Keiyaku.fork input");
+    onlyKeys(values, ["path", "akuma", "at", "settings", "repo"], "Keiyaku.fork input");
+    const path = resolve(nonblank(values.path, "path"));
+    if (typeof values.akuma !== "string")
+        throw new TypeError("akuma must be an AkuId");
+    const akuma = parseAkuId(values.akuma).id;
+    const at = nonblank(values.at, "at");
+    const settings = settingsOption(values.settings);
+    const repository = values.repo === undefined ? undefined : scopeForRepo(values.repo);
+    const receipt = await Akuma.at({ path, ...(settings === undefined ? {} : { settings }) })
+        .of({ id: akuma })
+        .fork({ at });
+    if (receipt.kind !== "forked")
+        return receipt;
+    const dispatch = repository === undefined
+        ? { kind: "none" }
+        : forkDispatchStage({ repository, parent: akuma, child: receipt.child });
+    return { kind: "forked", child: receipt.child, dispatch };
+}

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

@@ -0,0 +1,26 @@
+import type { Settings } from "../settings.js";
+export type Gate = string;
+export type GatesFromInput = Readonly<{
+    settings: Settings;
+    name?: string;
+}>;
+export type HookCommand = Readonly<{
+    argv: readonly string[];
+    timeoutMs: number;
+}>;
+export type WorktreeHooks = Readonly<{
+    create: readonly HookCommand[];
+    destroy: readonly HookCommand[];
+}>;
+export type WorktreeHooksFromInput = Readonly<{
+    settings: Settings;
+}>;
+export declare class SettingsError extends Error {
+    readonly kind = "settings";
+    constructor(message: string);
+}
+export declare function gatesFrom(input: GatesFromInput): readonly Gate[];
+export declare function worktreeHooksFrom(input: WorktreeHooksFromInput): WorktreeHooks;
+export declare function normalizedWorktreeHooks(value: unknown): WorktreeHooks;
+export declare const EMPTY_WORKTREE_HOOKS: WorktreeHooks;
+export declare function worktreeHooksOption(value: unknown): WorktreeHooks;

package/build/src/library/configuration.js

@@ -0,0 +1,100 @@
+import { gateWord } from "../core/facts/types.js";
+export class SettingsError extends Error {
+    kind = "settings";
+    constructor(message) {
+        super(message);
+        this.name = "SettingsError";
+    }
+}
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function namespaceFailure(view) {
+    if (view.kind !== "failed")
+        throw new Error("settings namespace failure expected");
+    throw new SettingsError(view.failures.map((failure) => `${failure.scope}: ${failure.diagnostic}`).join("; "));
+}
+export function gatesFrom(input) {
+    if (!record(input))
+        throw new TypeError("gatesFrom input must be an object");
+    const name = input.name ?? "default";
+    if (!gateWord(name))
+        throw new SettingsError("gate set name must match ^[a-z][a-z0-9-]{0,63}$");
+    const view = input.settings.namespace("gates");
+    if (view.kind === "failed")
+        namespaceFailure(view);
+    const selected = view.entries.find((entry) => entry.name === name);
+    if (selected === undefined) {
+        if (input.name === undefined)
+            return Object.freeze([]);
+        throw new SettingsError(`unknown gate set: ${name}`);
+    }
+    if (!Array.isArray(selected.value))
+        throw new SettingsError(`gate set '${name}' must be an array`);
+    const values = selected.value.map((value) => {
+        if (!gateWord(value))
+            throw new SettingsError(`gate set '${name}' contains an invalid gate word`);
+        return value;
+    });
+    if (new Set(values).size !== values.length)
+        throw new SettingsError(`gate set '${name}' contains duplicate gates`);
+    return Object.freeze(values);
+}
+function command(value, coordinate, ErrorType) {
+    if (!record(value))
+        throw new ErrorType(`${coordinate} must be an object`);
+    for (const key of Object.keys(value)) {
+        if (key !== "argv" && key !== "timeoutMs")
+            throw new ErrorType(`${coordinate} has unknown field: ${key}`);
+    }
+    if (!Array.isArray(value.argv) || value.argv.length === 0 || !value.argv.every((item) => typeof item === "string")) {
+        throw new ErrorType(`${coordinate}.argv must be a nonempty string array`);
+    }
+    if (value.argv[0].trim().length === 0)
+        throw new ErrorType(`${coordinate}.argv[0] must be nonblank`);
+    if (!Number.isSafeInteger(value.timeoutMs) || value.timeoutMs < 1 || value.timeoutMs > 2_147_483_647) {
+        throw new ErrorType(`${coordinate}.timeoutMs must be an integer from 1 through 2147483647`);
+    }
+    return Object.freeze({ argv: Object.freeze([...value.argv]), timeoutMs: value.timeoutMs });
+}
+function commands(value, coordinate, ErrorType) {
+    if (!Array.isArray(value))
+        throw new ErrorType(`${coordinate} must be an array`);
+    return Object.freeze(value.map((item, index) => command(item, `${coordinate}[${index}]`, ErrorType)));
+}
+export function worktreeHooksFrom(input) {
+    if (!record(input))
+        throw new TypeError("worktreeHooksFrom input must be an object");
+    const view = input.settings.namespace("worktree");
+    if (view.kind === "failed")
+        namespaceFailure(view);
+    for (const entry of view.entries) {
+        if (entry.name !== "create" && entry.name !== "destroy") {
+            throw new SettingsError(`worktree has unknown entry: ${entry.name}`);
+        }
+    }
+    const value = (phase) => {
+        const selected = view.entries.find((entry) => entry.name === phase);
+        return selected === undefined ? Object.freeze([]) : commands(selected.value, `worktree.${phase}`, SettingsError);
+    };
+    return Object.freeze({ create: value("create"), destroy: value("destroy") });
+}
+export function normalizedWorktreeHooks(value) {
+    if (!record(value))
+        throw new TypeError("hooks must be an object");
+    for (const key of Object.keys(value)) {
+        if (key !== "create" && key !== "destroy")
+            throw new TypeError(`hooks has unknown field: ${key}`);
+    }
+    return Object.freeze({
+        create: commands(value.create, "hooks.create", TypeError),
+        destroy: commands(value.destroy, "hooks.destroy", TypeError),
+    });
+}
+export const EMPTY_WORKTREE_HOOKS = Object.freeze({
+    create: Object.freeze([]),
+    destroy: Object.freeze([]),
+});
+export function worktreeHooksOption(value) {
+    return value === undefined ? EMPTY_WORKTREE_HOOKS : normalizedWorktreeHooks(value);
+}