@astrosheep/keiyaku 4.1.0 → 4.1.2

package/build/src/git/terminal-reconcile.js

@@ -0,0 +1,278 @@
+import { access } from "node:fs/promises";
+import { isKeiyakuOwnedRef, readRef, writeCommit, worktreeGitDirectory } from "./repository.js";
+import { gitObjectIdForSnapshot, mintSnapshotId } from "./identity.js";
+import { runDestroyHooks } from "./hooks.js";
+import { terminalSealExpectations as decodeTerminalSealExpectations, terminalSealSnapshots, observeTerminalWorkspace, } from "./terminal-seal.js";
+import { GitPlumbingError, runGit } from "./process.js";
+import { worktreePath } from "./workspace.js";
+const pathExists = (path) => access(path).then(() => true, () => false);
+async function removeTerminalWorktree(repository, topology, path) {
+    const registered = topology.paths.has(path);
+    if (!registered) {
+        return {
+            effect: { kind: "worktree", path, action: "unchanged" },
+            retained: await pathExists(path),
+        };
+    }
+    if (!(await pathExists(path))) {
+        await runGit(repository, ["worktree", "remove", path]);
+        topology.paths.delete(path);
+        return { effect: { kind: "worktree", path, action: "removed" }, retained: false };
+    }
+    try {
+        await runGit(repository, ["worktree", "remove", "--force", path]);
+    }
+    catch {
+        return { effect: { kind: "worktree", path, action: "unchanged" }, retained: true };
+    }
+    topology.paths.delete(path);
+    return { effect: { kind: "worktree", path, action: "removed" }, retained: false };
+}
+export async function updateRef(repository, ref, desired) {
+    const before = await readRef(repository, ref);
+    if (before === desired)
+        return { kind: "ref", name: ref, action: "unchanged", before, after: desired };
+    await runGit(repository, [
+        "update-ref",
+        "--no-deref",
+        ref,
+        gitObjectIdForSnapshot(desired),
+        before ?? "0".repeat(desired.length),
+    ]);
+    return { kind: "ref", name: ref, action: before === null ? "created" : "updated", before, after: desired };
+}
+export async function removeRef(repository, ref) {
+    const before = await readRef(repository, ref);
+    if (before === null)
+        return { kind: "ref", name: ref, action: "unchanged", before: null, after: null };
+    await runGit(repository, ["update-ref", "--no-deref", "-d", ref, before]);
+    return { kind: "ref", name: ref, action: "removed", before, after: null };
+}
+async function removeRefWithCustody(repository, ref, custodian, expectedCustodian) {
+    const before = await readRef(repository, ref);
+    if (before === null)
+        return { kind: "ref", name: ref, action: "unchanged", before: null, after: null };
+    if ((await readRef(repository, custodian)) !== expectedCustodian) {
+        return { kind: "ref", name: ref, action: "unchanged", before, after: before };
+    }
+    await runGit(repository, ["update-ref", "--stdin", "--no-deref"], [
+        "start",
+        `verify ${custodian} ${gitObjectIdForSnapshot(expectedCustodian)}`,
+        `delete ${ref} ${before}`,
+        "prepare",
+        "commit",
+        "",
+    ].join("\n"));
+    return { kind: "ref", name: ref, action: "removed", before, after: null };
+}
+function retainedRefEffect(ref, snapshot) {
+    return { kind: "ref", name: ref, action: "unchanged", before: snapshot, after: snapshot };
+}
+async function refRows(repository) {
+    const output = (await runGit(repository, ["for-each-ref", "--format=%(refname)%00%(objectname)"])).toString("utf8");
+    if (output.length === 0)
+        return [];
+    return output
+        .trimEnd()
+        .split("\n")
+        .map((row) => {
+        const [ref, oid, extra] = row.split("\0");
+        if (ref === undefined || oid === undefined || extra !== undefined)
+            throw new Error("Git ref row is malformed");
+        return { ref, oid };
+    });
+}
+async function commitIsAncestor(repository, ancestor, descendant) {
+    try {
+        await runGit(repository, ["merge-base", "--is-ancestor", gitObjectIdForSnapshot(ancestor), descendant]);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof GitPlumbingError && error.status === 1)
+            return false;
+        throw error;
+    }
+}
+async function snapshotCustodian(repository, snapshot) {
+    for (const row of await refRows(repository)) {
+        if (isKeiyakuOwnedRef(row.ref))
+            continue;
+        if (await commitIsAncestor(repository, snapshot, row.oid))
+            return { ref: row.ref, oid: mintSnapshotId(row.oid) };
+    }
+    return null;
+}
+function fromPrimaryWorktree(repository) {
+    return { ...repository, effectiveCwd: repository.primaryWorktree };
+}
+function complete(effects = [], lag = []) {
+    return { effects, lag };
+}
+function retainTerminalWorktree(path, retainedLag, { effects, lag }) {
+    effects.push({ kind: "worktree", path, action: "unchanged" });
+    lag.push(retainedLag);
+    return complete(effects, lag);
+}
+async function terminalSealExpectations(channel, state) {
+    const snapshots = terminalSealSnapshots(state);
+    const objects = await channel.readObjects(snapshots.map(gitObjectIdForSnapshot));
+    return decodeTerminalSealExpectations(state, objects);
+}
+async function removeSealedTerminalWorktree({ repository, topology, path, state, expected, hooks, retryHooks, acc, }) {
+    if (topology.paths.has(path) && (await pathExists(path))) {
+        const terminal = state.terminal;
+        if (terminal === null)
+            throw new Error(`terminal worktree cleanup received active Contract ${state.id}`);
+        const canRecover = terminal.kind === "abandoned";
+        let recovery = null;
+        const recordRecovery = async (workspace) => {
+            const snapshot = mintSnapshotId(await writeCommit({
+                repository,
+                tree: workspace.tree,
+                parent: gitObjectIdForSnapshot(recovery?.snapshot ?? workspace.head),
+                message: `${state.id}: ephemeral abandoned-workspace recovery\n\nKeiyaku-Contract: ${state.id}`,
+                actor: "Keiyaku Recovery",
+                at: terminal.at,
+            }));
+            const effect = {
+                kind: "recovery-snapshot",
+                action: "created",
+                snapshot,
+                retention: "ephemeral",
+            };
+            const existing = acc.effects.findIndex((item) => item.kind === "recovery-snapshot");
+            if (existing < 0)
+                acc.effects.push(effect);
+            else
+                acc.effects[existing] = effect;
+            return { snapshot, workspace };
+        };
+        const before = await observeTerminalWorkspace(repository, path, expected);
+        const beforeWorkspace = before.workspace;
+        const beforeHooks = before.unsealed;
+        if (beforeHooks !== null) {
+            if (!canRecover || beforeWorkspace.submodules.length > 0) {
+                return retainTerminalWorktree(path, beforeHooks, acc);
+            }
+            recovery = await recordRecovery(beforeWorkspace);
+        }
+        const hookLag = await runDestroyHooks(path, await worktreeGitDirectory(repository, path), hooks, retryHooks);
+        if (hookLag !== null)
+            return retainTerminalWorktree(path, hookLag, acc);
+        const after = await observeTerminalWorkspace(repository, path, expected);
+        const afterWorkspace = after.workspace;
+        const afterHooks = after.unsealed;
+        if (afterHooks !== null) {
+            if (!canRecover || afterWorkspace.submodules.length > 0) {
+                return retainTerminalWorktree(path, afterHooks, acc);
+            }
+        }
+        if (canRecover &&
+            (recovery === null ||
+                recovery.workspace.head !== afterWorkspace.head ||
+                recovery.workspace.tree !== afterWorkspace.tree) &&
+            (recovery !== null ||
+                beforeWorkspace.head !== afterWorkspace.head ||
+                beforeWorkspace.tree !== afterWorkspace.tree)) {
+            recovery = await recordRecovery(afterWorkspace);
+        }
+    }
+    const removal = await removeTerminalWorktree(repository, topology, path);
+    if (removal.retained)
+        return retainTerminalWorktree(path, { kind: "worktree-retained", path }, acc);
+    acc.effects.push(removal.effect);
+    return null;
+}
+async function targetCustodyForClaimedIntegration(repository, state, integration) {
+    if (state.terminal?.kind !== "claimed" || state.coordinates.target === undefined)
+        return null;
+    const target = await readRef(repository, state.coordinates.target);
+    if (target === null)
+        return null;
+    const oid = mintSnapshotId(target);
+    return (await commitIsAncestor(repository, integration, oid)) ? { ref: state.coordinates.target, oid } : null;
+}
+function sealedTree(expected, snapshot) {
+    const tree = expected.treeBySnapshot.get(snapshot);
+    if (tree === undefined)
+        throw new Error(`terminal seal tree was not resolved: ${snapshot}`);
+    return tree;
+}
+async function releaseTerminalCustody({ repository, state, resolveSeal, ref, pin, acc: { effects }, }) {
+    const [deliveryRef, candidatePin] = await Promise.all([readRef(repository, ref), readRef(repository, pin)]);
+    if (deliveryRef === null && candidatePin === null)
+        return;
+    if (state.delivery === null) {
+        const custodian = await snapshotCustodian(repository, state.coordinates.start);
+        if (deliveryRef !== null) {
+            effects.push(custodian === null
+                ? retainedRefEffect(ref, deliveryRef)
+                : await removeRefWithCustody(repository, ref, custodian.ref, custodian.oid));
+        }
+        if (candidatePin !== null)
+            effects.push(await removeRef(repository, pin));
+        return;
+    }
+    const tender = state.delivery.data.tenderSnapshot;
+    const integration = state.currentIntegration?.snapshot ?? state.delivery.data.integration.snapshot;
+    const target = await targetCustodyForClaimedIntegration(repository, state, integration);
+    if (deliveryRef !== null && target !== null) {
+        if (tender === integration) {
+            effects.push(await removeRefWithCustody(repository, ref, target.ref, target.oid));
+        }
+        else {
+            const expected = await resolveSeal();
+            if (sealedTree(expected, tender) === sealedTree(expected, integration)) {
+                effects.push(await removeRefWithCustody(repository, ref, target.ref, target.oid));
+            }
+            else {
+                effects.push(retainedRefEffect(ref, deliveryRef));
+            }
+        }
+    }
+    else if (deliveryRef !== null) {
+        effects.push(retainedRefEffect(ref, deliveryRef));
+    }
+    if (candidatePin !== null) {
+        if (target !== null || (tender === integration && deliveryRef !== null)) {
+            effects.push(target !== null
+                ? await removeRefWithCustody(repository, pin, target.ref, target.oid)
+                : await removeRefWithCustody(repository, pin, ref, tender));
+        }
+        else {
+            effects.push(retainedRefEffect(pin, candidatePin));
+        }
+    }
+}
+export async function reconcileTerminalManagedWorktree({ repository, channel, hooks, retryHooks, retainTerminalWorktree, place }, state, topology, acc, { ref, pin }) {
+    const primary = fromPrimaryWorktree(repository);
+    const path = place === undefined ? undefined : worktreePath(repository, place);
+    const resolveSeal = async () => await terminalSealExpectations(channel, state);
+    if (path === undefined) {
+        if (retainTerminalWorktree === true)
+            return complete(acc.effects, acc.lag);
+        await releaseTerminalCustody({ repository: primary, state, resolveSeal, ref, pin, acc });
+        return complete(acc.effects, acc.lag);
+    }
+    const expected = await resolveSeal();
+    acc.effects.push(await updateRef(primary, ref, state.delivery?.data.tenderSnapshot ?? state.coordinates.start));
+    if (state.delivery !== null) {
+        acc.effects.push(await updateRef(primary, pin, state.currentIntegration?.snapshot ?? state.delivery.data.integration.snapshot));
+    }
+    if (retainTerminalWorktree === true)
+        return complete(acc.effects, acc.lag);
+    const retained = await removeSealedTerminalWorktree({
+        repository: primary,
+        topology,
+        path,
+        state,
+        expected,
+        hooks,
+        retryHooks,
+        acc,
+    });
+    if (retained !== null)
+        return retained;
+    await releaseTerminalCustody({ repository: primary, state, resolveSeal: async () => expected, ref, pin, acc });
+    return complete(acc.effects, acc.lag);
+}

package/build/src/git/terminal-seal.js

@@ -2,13 +2,17 @@ import { gitObjectId, gitObjectIdForSnapshot, mintSnapshotId } from "./identity.
 import { runGit } from "./process.js";
 import { captureWorkspaceTree } from "./workspace.js";
 export function terminalSealSnapshots(state) {
-    return [...new Set([
+    return [
+        ...new Set([
             state.coordinates.start,
-            ...(state.delivery === null ? [] : [
-                state.delivery.data.tenderSnapshot,
-                ...(state.currentIntegration === null ? [] : [state.currentIntegration.snapshot]),
-            ]),
-        ])];
+            ...(state.delivery === null
+                ? []
+                : [
+                    state.delivery.data.tenderSnapshot,
+                    ...(state.currentIntegration === null ? [] : [state.currentIntegration.snapshot]),
+                ]),
+        ]),
+    ];
 }
 function commitMetadata(snapshot, result) {
     if (result === undefined || result.kind === "missing") {
@@ -33,10 +37,7 @@ function commitMetadata(snapshot, result) {
 }
 export function terminalSealExpectations(state, objects) {
     const snapshots = terminalSealSnapshots(state);
-    const metadata = new Map(snapshots.map((snapshot) => [
-        snapshot,
-        commitMetadata(snapshot, objects.get(gitObjectIdForSnapshot(snapshot))),
-    ]));
+    const metadata = new Map(snapshots.map((snapshot) => [snapshot, commitMetadata(snapshot, objects.get(gitObjectIdForSnapshot(snapshot)))]));
     const treeBySnapshot = new Map([...metadata].map(([snapshot, commit]) => [snapshot, commit.tree]));
     if (state.delivery === null) {
         return { heads: [state.coordinates.start], trees: [...treeBySnapshot.values()], treeBySnapshot };
@@ -47,12 +48,14 @@ export function terminalSealExpectations(state, objects) {
         throw new Error(`terminal seal metadata was not resolved: ${tender}`);
     const [tenderParent] = tenderMetadata.parents;
     return {
-        heads: [...new Set([
+        heads: [
+            ...new Set([
                 state.coordinates.start,
                 ...(tenderParent === undefined ? [] : [tenderParent]),
                 tender,
                 state.currentIntegration?.snapshot ?? state.delivery.data.integration.snapshot,
-            ])],
+            ]),
+        ],
         trees: [...treeBySnapshot.values()],
         treeBySnapshot,
     };

package/build/src/git/tree.js

@@ -1,8 +1,11 @@
 import { createHash } from "node:crypto";
 import { gitObjectId } from "./identity.js";
 export function validPath(path) {
-    if (path.length === 0 || path.startsWith("/") || path.endsWith("/") || path.includes("\0")
-        || path.split("/").some((part) => part.length === 0 || part === "." || part === ".."))
+    if (path.length === 0 ||
+        path.startsWith("/") ||
+        path.endsWith("/") ||
+        path.includes("\0") ||
+        path.split("/").some((part) => part.length === 0 || part === "." || part === ".."))
         throw new Error(`invalid Git path: ${path}`);
 }
 function addEntry(root, path, change) {

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

@@ -15,9 +15,28 @@ export type WorkspaceTree = Readonly<{
     changes: WorkspaceChanges;
 }>;
 export declare function worktreePath(repository: GitRepository, place: string): string;
+export type ManagedWorktreeFollow = Readonly<{
+    kind: "followed";
+    before: SnapshotId;
+    after: SnapshotId;
+}> | Readonly<{
+    kind: "unchanged";
+}> | Readonly<{
+    kind: "retained";
+    head: SnapshotId;
+    reason: "head-moved" | "head-attached" | "operation-in-progress" | "unsupported-parent-shape";
+}>;
+/** Follow an accepted tender only through the native index-and-HEAD transition. */
+export declare function followManagedWorktree(repository: GitRepository, workspace: string, tender: SnapshotId): Promise<ManagedWorktreeFollow>;
 export declare function withPrivateGitIndex<Value>(action: (environment: Readonly<{
     GIT_INDEX_FILE: string;
 }>) => Value | PromiseLike<Value>): Promise<Value>;
+/** Observe MERGE_HEAD in an appointed workspace, or undefined when absent. */
+export declare function workspaceMergeHead(repository: GitRepository, workspace: string): Promise<SnapshotId | undefined>;
+/** True when the appointed workspace already has Git MERGE_HEAD. */
+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<{
     staged: number;
     unstaged: number;
@@ -27,13 +46,16 @@ export type WorkspaceChangeCounts = Readonly<{
 export type ContractWorkspaceLocation = Readonly<{
     kind: "worktree";
     path: string;
-}> | Readonly<{
-    kind: "here";
+}>;
+export type ContractWorkspaceMerge = Readonly<{
+    head: SnapshotId;
+    unmergedPaths: readonly string[];
 }>;
 export type ContractWorkspaceObservation = Readonly<{
     kind: "clean" | "dirty";
     location: ContractWorkspaceLocation;
     counts: WorkspaceChangeCounts;
+    merge: ContractWorkspaceMerge | null;
 }> | Readonly<{
     kind: "unavailable";
     location: ContractWorkspaceLocation;

package/build/src/git/workspace.js

@@ -1,11 +1,74 @@
-import { mkdtemp, rm } from "node:fs/promises";
+import { access, mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { gitObjectId, mintSnapshotId } from "./identity.js";
-import { runGit, runGitWithEnvironment } from "./process.js";
-const WORKTREE_DIRECTORY = ["keiyaku", "wt"];
+import { GitPlumbingError, runGit, runGitWithEnvironment } from "./process.js";
+import { worktreeGitDirectory } from "./repository.js";
+const WORKTREE_DIRECTORY = [".keiyaku", "wt"];
 export function worktreePath(repository, place) {
-    return resolve(repository.commonDirectory, ...WORKTREE_DIRECTORY, place);
+    return resolve(repository.primaryWorktree, ...WORKTREE_DIRECTORY, place);
+}
+async function workspaceRevision(repository, workspace, revision) {
+    try {
+        const value = (await runGit(repository, ["-C", workspace, "rev-parse", "--verify", "--quiet", revision]))
+            .toString("utf8")
+            .trim();
+        return value.length === 0 ? null : mintSnapshotId(value);
+    }
+    catch (error) {
+        if (error instanceof GitPlumbingError && error.status === 1)
+            return null;
+        throw error;
+    }
+}
+async function workspaceOperationState(repository, workspace, gitDirectory) {
+    const paths = ["rebase-merge", "rebase-apply", "CHERRY_PICK_HEAD", "REVERT_HEAD"];
+    const other = await Promise.all(paths.map(async (path) => {
+        try {
+            await access(join(gitDirectory, path));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }));
+    const unmerged = (await runGit(repository, ["-C", workspace, "ls-files", "--unmerged", "-z"])).length > 0;
+    return { other: other.some(Boolean), unmerged };
+}
+/** Follow an accepted tender only through the native index-and-HEAD transition. */
+export async function followManagedWorktree(repository, workspace, tender) {
+    const head = await workspaceRevision(repository, workspace, "HEAD");
+    if (head === null)
+        throw new Error("managed worktree HEAD is missing");
+    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" };
+    if (head === tender)
+        return { kind: "unchanged" };
+    const parents = (await runGit(repository, ["show", "-s", "--format=%P", gitObjectId(tender)]))
+        .toString("utf8")
+        .trim()
+        .split(" ")
+        .filter((parent) => parent.length > 0)
+        .map((parent) => mintSnapshotId(parent));
+    if (parents.length > 0 && head !== parents[0])
+        return { kind: "retained", head, reason: "head-moved" };
+    if (parents.length !== 1 && parents.length !== 2)
+        return { kind: "retained", head, reason: "unsupported-parent-shape" };
+    const gitDirectory = await worktreeGitDirectory(repository, workspace);
+    const mergeHead = await workspaceRevision(repository, workspace, "MERGE_HEAD");
+    const operation = await workspaceOperationState(repository, workspace, gitDirectory);
+    const admitted = parents.length === 1
+        ? mergeHead === null && !operation.other && !operation.unmerged
+        : mergeHead === parents[1] && !operation.other && !operation.unmerged;
+    if (!admitted)
+        return { kind: "retained", head, reason: "operation-in-progress" };
+    await runGit(repository, ["-C", workspace, "reset", "--mixed", gitObjectId(tender)]);
+    return { kind: "followed", before: head, after: tender };
 }
 export async function withPrivateGitIndex(action) {
     const directory = await mkdtemp(join(tmpdir(), "keiyaku-v4-index-"));
@@ -29,15 +92,23 @@ function fields(record, count) {
     result.push(record.slice(start));
     return result;
 }
-async function workspaceChanges(repository, workspace) {
+async function workspaceStatus(repository, workspace) {
     const records = (await runGit(repository, [
-        "-C", workspace,
-        "status", "--porcelain=v2", "-z", "--untracked-files=all", "--ignore-submodules=none",
-    ])).toString("utf8").split("\0");
+        "-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();
+    const unmerged = new Set();
     for (let index = 0; index < records.length - 1; index += 1) {
         const record = records[index];
         const kind = record[0];
@@ -50,6 +121,8 @@ async function workspaceChanges(repository, workspace) {
             const xy = parts[1];
             const sub = parts[2];
             const path = parts.at(-1);
+            if (kind === "u")
+                unmerged.add(path);
             if (xy[0] !== ".")
                 staged.add(path);
             if (xy[1] !== ".")
@@ -75,8 +148,34 @@ async function workspaceChanges(repository, workspace) {
         unstaged: [...unstaged].sort(),
         untracked: [...untracked].sort(),
         submodules: [...submodules].sort(),
+        unmergedPaths: [...unmerged].sort(),
     };
 }
+async function workspaceChanges(repository, workspace) {
+    const { unmergedPaths: _unmergedPaths, ...changes } = await workspaceStatus(repository, workspace);
+    return changes;
+}
+/** 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"]))
+            .toString("utf8")
+            .trim());
+    }
+    catch (error) {
+        if (error instanceof GitPlumbingError && error.status === 1)
+            return undefined;
+        throw error;
+    }
+}
+/** True when the appointed workspace already has Git MERGE_HEAD. */
+export async function workspaceMergeStatePresent(repository, workspace) {
+    return (await workspaceMergeHead(repository, workspace)) !== undefined;
+}
+/** Sorted unique unmerged index paths from porcelain status. */
+export async function unmergedWorkspacePaths(repository, workspace) {
+    return (await workspaceStatus(repository, workspace)).unmergedPaths;
+}
 function countsOf(changes) {
     return {
         staged: changes.staged.length,
@@ -87,9 +186,12 @@ function countsOf(changes) {
 }
 export async function observeWorkspace(repository, location, workspace) {
     try {
-        const counts = countsOf(await workspaceChanges(repository, workspace));
+        const status = await workspaceStatus(repository, workspace);
+        const counts = countsOf(status);
         const dirty = counts.staged > 0 || counts.unstaged > 0 || counts.untracked > 0 || counts.submodules > 0;
-        return { kind: dirty ? "dirty" : "clean", location, counts };
+        const head = await workspaceMergeHead(repository, workspace);
+        const merge = head === undefined ? null : { head, unmergedPaths: status.unmergedPaths };
+        return { kind: dirty ? "dirty" : "clean", location, counts, merge };
     }
     catch {
         return { kind: "unavailable", location };
@@ -117,11 +219,11 @@ export async function captureWorkspaceTree(repository, workspace) {
     const identities = (await runGit(repository, ["-C", workspace, "show", "-s", "--format=%H%n%T%n%cI", "HEAD"]))
         .toString("utf8")
         .split("\n");
-    if (identities.length !== 4
-        || identities[0] === undefined
-        || identities[1] === undefined
-        || identities[2] === undefined
-        || identities[3] !== "") {
+    if (identities.length !== 4 ||
+        identities[0] === undefined ||
+        identities[1] === undefined ||
+        identities[2] === undefined ||
+        identities[3] !== "") {
         throw new Error("workspace HEAD/tree/time resolution returned an unexpected shape");
     }
     const head = mintSnapshotId(identities[0]);
@@ -137,7 +239,9 @@ export async function captureWorkspaceTree(repository, workspace) {
         await runGitWithEnvironment(repository, ["-C", workspace, "read-tree", "HEAD"], undefined, environment);
         await runGitWithEnvironment(repository, ["-C", workspace, "add", "--all"], undefined, environment);
         return {
-            tree: gitObjectId((await runGitWithEnvironment(repository, ["-C", workspace, "write-tree"], undefined, environment)).toString("utf8").trim(), "workspace tree"),
+            tree: gitObjectId((await runGitWithEnvironment(repository, ["-C", workspace, "write-tree"], undefined, environment))
+                .toString("utf8")
+                .trim(), "workspace tree"),
             head,
             at,
             dirty,

package/build/src/identity/coordinates.js

@@ -1,4 +1,6 @@
-function prefix(family) { return `${family}/`; }
+function prefix(family) {
+    return `${family}/`;
+}
 function validSegment(segment) {
     return segment.length > 0 && !/[\/\s\p{Cc}]/u.test(segment);
 }

package/build/src/identity/selector.js

@@ -10,9 +10,12 @@ 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] ?? "")) {
+    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/<akuma-pattern>/<hex-pattern> and contain *");
     }
     return value;

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

@@ -0,0 +1,6 @@
+import type { AkumaKanshiRow } from "./report.js";
+export declare const FLEET_VISIBLE_ROWS = 10;
+export declare const FLEET_SNAPSHOT_ROWS = 3;
+export declare function fleetUpdatedAt(row: AkumaKanshiRow): string | null;
+/** The Fleet aperture and snapshot readers share this one visible-row order. */
+export declare function visibleFleetRows(rows: readonly AkumaKanshiRow[]): readonly AkumaKanshiRow[];

package/build/src/kanshi/fleet.js

@@ -0,0 +1,27 @@
+export const FLEET_VISIBLE_ROWS = 10;
+export const FLEET_SNAPSHOT_ROWS = 3;
+export function fleetUpdatedAt(row) {
+    const lifeAt = "lifeAt" in row ? row.lifeAt : null;
+    const lastActivityAt = "lastActivityAt" in row ? row.lastActivityAt : null;
+    if (lifeAt === null)
+        return lastActivityAt;
+    if (lastActivityAt === null)
+        return lifeAt;
+    return lifeAt > lastActivityAt ? lifeAt : lastActivityAt;
+}
+/** The Fleet aperture and snapshot readers share this one visible-row order. */
+export function visibleFleetRows(rows) {
+    return [...rows]
+        .sort((left, right) => {
+        const leftAt = fleetUpdatedAt(left);
+        const rightAt = fleetUpdatedAt(right);
+        if (leftAt === rightAt)
+            return 0;
+        if (leftAt === null)
+            return 1;
+        if (rightAt === null)
+            return -1;
+        return leftAt > rightAt ? -1 : 1;
+    })
+        .slice(0, FLEET_VISIBLE_ROWS);
+}

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, KanshiReport, Section, TaskKanshiRow, TaskKanshiWorld, KanshiRegionSelection, RegionDeclaration, RegionIntersection, RegionPathMatch, RegionRead, } from "./report.js";
+export type { AkumaKanshiRow, AkumaKanshiWorld, ContractEndpointObservation, ContractHolderObservation, ContractKanshiBoard, ContractKanshiRow, CurrentPhysicalIssue, KanshiReport, Section, TaskKanshiRow, TaskKanshiWorld, KanshiRegionSelection, RegionDeclaration, RegionOverlap, RegionRead, } from "./report.js";
 export type { KanshiSelection } from "./select.js";