@astrosheep/keiyaku 2.9.12 → 4.0.0

package/build/src/protocol/read/status.js

@@ -0,0 +1,47 @@
+import { observeGit, observeContract } from "../../git/observe.js";
+import { deliveryWorktreePath } from "../../git/reconcile.js";
+import { gateReports } from "../../core/facts/gate.js";
+function phaseFor(state) {
+    if (state.terminal?.kind === "claimed")
+        return "claimed";
+    if (state.terminal?.kind === "abandoned")
+        return "abandoned";
+    if (state.delivery !== null)
+        return "pending-delivery";
+    if (state.bound !== null)
+        return "bound";
+    return "waiting";
+}
+function rowFor(repository, state) {
+    const workspace = state.coordinates.workspace;
+    const gates = gateReports(state);
+    return {
+        id: state.id,
+        phase: phaseFor(state),
+        disposition: state.terminal === null ? "active" : "terminal",
+        workspace,
+        worktreePath: workspace === "worktree" ? deliveryWorktreePath(repository, state.id) : null,
+        target: state.coordinates.target ?? null,
+        candidate: state.delivery?.data.candidate ?? null,
+        gates: {
+            reports: gates.reports.map((report) => ({ gate: report.gate, current: report.current })),
+            satisfied: gates.satisfied,
+        },
+    };
+}
+/** Build the Contract board from one immutable git observation. */
+export function readContractBoard(repository) {
+    const observed = observeGit(repository);
+    const rows = [];
+    for (const value of observed.contracts.values()) {
+        if (value.state === null)
+            continue;
+        rows.push(rowFor(repository, value.state));
+    }
+    return { root: repository.primaryWorktree, rows };
+}
+/** Observe one Contract without enumerating the Contract world. */
+export function readContractObservation(repository, id) {
+    const state = observeContract(repository, id).state;
+    return state === null ? { kind: "missing", id } : { kind: "present", row: rowFor(repository, state) };
+}

package/build/src/protocol/run.d.ts

@@ -0,0 +1,39 @@
+import { type GitDecisionObservation } from "../git/observe.js";
+import type { GitRepository } from "../git/repository.js";
+import type { AttemptContext, DecideInput, OfferDecision } from "../core/decide.js";
+import type { Offer, TreeUpdate } from "../core/facts/offer.js";
+import { type ContractId } from "../core/facts/types.js";
+import { type AcceptedAdmission, type AttemptTerminal } from "./attempt.js";
+export type ProtocolTerminal = Readonly<{
+    kind: "exhausted";
+}> | AttemptTerminal;
+export type ProtocolResult<Refusal> = AcceptedAdmission | Readonly<{
+    kind: "refused";
+    refusal: Refusal;
+}> | ProtocolTerminal;
+export type CompanionDecorator = (input: Readonly<{
+    repository: GitRepository;
+    observation: GitDecisionObservation;
+    contractId: ContractId;
+    offer: Offer;
+}>) => readonly TreeUpdate[];
+type RunProtocolInput<Input extends Readonly<{
+    contractId: ContractId;
+}>, Refusal> = Readonly<{
+    input: Input;
+    repository: GitRepository;
+    contracts: readonly ContractId[];
+    attempts: readonly AttemptContext[];
+    decide: (input: DecideInput<Input>) => OfferDecision<Refusal>;
+    /** Override the targeted observer only for intents that need a full snapshot. */
+    observe?: (repository: GitRepository, contracts: readonly ContractId[]) => GitDecisionObservation;
+    /** Mint verb-owned entries from the exact size of this attempt's observation. */
+    extendAttempt?: (attempt: AttemptContext, observedContractCount: number) => AttemptContext;
+    /** Add opaque companions from the exact immutable observation for this attempt. */
+    decorateOffer?: CompanionDecorator;
+}>;
+/** Run bounded, verb-neutral attempts and return one real admission on acceptance. */
+export declare function runProtocol<Input extends Readonly<{
+    contractId: ContractId;
+}>, Refusal>(input: RunProtocolInput<Input, Refusal>): ProtocolResult<Refusal>;
+export {};

package/build/src/protocol/run.js

@@ -0,0 +1,36 @@
+import { observeContractsForAdmission } from "../git/observe.js";
+import { admitDecidedOffer } from "./attempt.js";
+/** Run bounded, verb-neutral attempts and return one real admission on acceptance. */
+export function runProtocol(input) {
+    const attempts = input.attempts;
+    const contracts = input.contracts;
+    const observe = input.observe ?? observeContractsForAdmission;
+    for (let index = 0; index < attempts.length; index += 1) {
+        const baseAttempt = attempts[index];
+        const decisionObservation = observe(input.repository, contracts);
+        const observation = decisionObservation.decision;
+        const attempt = input.extendAttempt === undefined
+            ? baseAttempt
+            : input.extendAttempt(baseAttempt, observation.size);
+        const decision = input.decide({ input: input.input, attempt, observation });
+        if (decision.kind === "refused")
+            return { kind: "refused", refusal: decision.refusal };
+        const companions = input.decorateOffer === undefined
+            ? []
+            : input.decorateOffer({
+                repository: input.repository,
+                observation: decisionObservation,
+                contractId: input.input.contractId,
+                offer: decision.offer,
+            });
+        const offer = companions.length === 0
+            ? decision.offer
+            : { ...decision.offer, companions: [...(decision.offer.companions ?? []), ...companions] };
+        const result = admitDecidedOffer(input.repository, decisionObservation, attempt, offer, input.input.contractId);
+        if (result.kind === "accepted" || result.kind === "publication-failed")
+            return result;
+        if (result.kind === "collision" && index + 1 === attempts.length)
+            return result;
+    }
+    return { kind: "exhausted" };
+}

package/build/src/runtime/proc/line-rpc.d.ts

@@ -0,0 +1,37 @@
+export type LineRpcNotification = Readonly<{
+    method: string;
+    params?: Readonly<Record<string, unknown>>;
+}>;
+export type LineRpcServerRequest = LineRpcNotification & Readonly<{
+    id: number | string;
+}>;
+export type LineRpcExit = Readonly<{
+    code: number | null;
+    signal: NodeJS.Signals | null;
+    stderr: string;
+}>;
+export declare class LineRpcProcess {
+    private readonly child;
+    private readonly pending;
+    private readonly notifications;
+    private readonly serverRequests;
+    private readonly exited;
+    private nextId;
+    private stdout;
+    private stderr;
+    private closed;
+    constructor(input: Readonly<{
+        argv: readonly [string, ...string[]];
+        cwd: string;
+        env?: NodeJS.ProcessEnv;
+    }>);
+    onNotification(listener: (value: LineRpcNotification) => void): void;
+    onServerRequest(listener: (value: LineRpcServerRequest) => void): void;
+    onExit(listener: (value: LineRpcExit) => void): void;
+    private consume;
+    private receive;
+    private fail;
+    request(method: string, params?: Readonly<Record<string, unknown>>): Promise<unknown>;
+    notify(method: string): void;
+    close(force?: boolean): Promise<void>;
+}

package/build/src/runtime/proc/line-rpc.js

@@ -0,0 +1,124 @@
+import { spawn } from "node:child_process";
+import { terminateProcessTree } from "./run.js";
+function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function text(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+export class LineRpcProcess {
+    child;
+    pending = new Map();
+    notifications = new Set();
+    serverRequests = new Set();
+    exited;
+    nextId = 1;
+    stdout = "";
+    stderr = "";
+    closed = false;
+    constructor(input) {
+        this.child = spawn(input.argv[0], input.argv.slice(1), {
+            cwd: input.cwd,
+            env: input.env ?? process.env,
+            detached: true,
+            stdio: ["pipe", "pipe", "pipe"],
+            windowsHide: true,
+        });
+        this.child.stdout.setEncoding("utf8");
+        this.child.stderr.setEncoding("utf8");
+        this.child.stdout.on("data", (chunk) => this.consume(chunk));
+        this.child.stderr.on("data", (chunk) => { this.stderr = `${this.stderr}${chunk}`.slice(-4_000); });
+        this.child.on("error", (error) => this.fail(error));
+        this.exited = new Promise((resolve) => this.child.once("close", (code, signal) => {
+            this.closed = true;
+            this.fail(new Error(`line RPC process exited${code === null ? "" : ` with code ${code}`}`));
+            resolve({ code, signal, stderr: this.stderr.trim() });
+        }));
+    }
+    onNotification(listener) { this.notifications.add(listener); }
+    onServerRequest(listener) { this.serverRequests.add(listener); }
+    onExit(listener) { void this.exited.then(listener); }
+    consume(chunk) {
+        this.stdout += chunk;
+        for (;;) {
+            const newline = this.stdout.indexOf("\n");
+            if (newline < 0)
+                return;
+            const line = this.stdout.slice(0, newline).trim();
+            this.stdout = this.stdout.slice(newline + 1);
+            if (line.length > 0)
+                this.receive(line);
+        }
+    }
+    receive(line) {
+        let decoded;
+        try {
+            decoded = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        const message = object(decoded);
+        if (message === undefined)
+            return;
+        if (typeof message.id === "number" && ("result" in message || "error" in message)) {
+            const pending = this.pending.get(message.id);
+            if (pending === undefined)
+                return;
+            this.pending.delete(message.id);
+            const error = object(message.error);
+            if (error !== undefined)
+                pending.reject(new Error(text(error.message) ?? "line RPC error"));
+            else
+                pending.resolve(message.result);
+            return;
+        }
+        const method = text(message.method);
+        if (method === undefined)
+            return;
+        const params = object(message.params);
+        if (typeof message.id === "number" || typeof message.id === "string") {
+            for (const listener of this.serverRequests)
+                listener({ id: message.id, method, ...(params === undefined ? {} : { params }) });
+            return;
+        }
+        for (const listener of this.notifications)
+            listener({ method, ...(params === undefined ? {} : { params }) });
+    }
+    fail(error) {
+        for (const pending of this.pending.values())
+            pending.reject(error);
+        this.pending.clear();
+    }
+    request(method, params) {
+        if (this.closed)
+            return Promise.reject(new Error("line RPC process is closed"));
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            this.child.stdin.write(`${JSON.stringify({ id, method, ...(params === undefined ? {} : { params }) })}\n`, (error) => {
+                if (error === null || error === undefined)
+                    return;
+                this.pending.delete(id);
+                reject(error);
+            });
+        });
+    }
+    notify(method) {
+        if (!this.closed)
+            this.child.stdin.write(`${JSON.stringify({ method })}\n`);
+    }
+    async close(force = false) {
+        if (this.closed) {
+            await this.exited;
+            return;
+        }
+        this.closed = true;
+        this.fail(new Error("line RPC process is closed"));
+        this.child.stdin.end();
+        await terminateProcessTree(this.child.pid, force);
+        await this.exited;
+    }
+}

package/build/src/runtime/proc/run.d.ts

@@ -0,0 +1,54 @@
+type ProcessLaunch = Readonly<{
+    readonly argv: readonly string[];
+    readonly cwd?: string;
+    readonly env?: NodeJS.ProcessEnv;
+}>;
+export type ProcessInput = ProcessLaunch & Readonly<{
+    readonly timeoutMs: number;
+}>;
+type ProcessTerminal = Readonly<{
+    readonly kind: "terminal";
+    readonly code: number;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly truncated: boolean;
+}>;
+type ProcessTimeout = Readonly<{
+    readonly kind: "timeout";
+}>;
+type ProcessSpawnError = Readonly<{
+    readonly kind: "spawn-error";
+    readonly diagnostic: string;
+}>;
+type ProcessUnknownExit = Readonly<{
+    readonly kind: "unknown-exit";
+}>;
+export type ProcessOutcome = ProcessTerminal | ProcessTimeout | ProcessSpawnError | ProcessUnknownExit;
+export type ProcessCollar = Readonly<{
+    pid: number;
+    processGroup: number;
+    spawnedAt: string;
+}>;
+export type ProcessTreeProbe = Readonly<{
+    kind: "gone";
+}> | Readonly<{
+    kind: "alive";
+}> | Readonly<{
+    kind: "unverifiable";
+    diagnostic: string;
+}>;
+export type PutDownEvidence = "killed" | "already-dead" | "alive-after-sigkill" | "unavailable";
+export type DetachedProcessInput = Readonly<{
+    argv: readonly string[];
+    cwd: string;
+    env?: NodeJS.ProcessEnv;
+    log: string;
+}>;
+export declare function terminateProcessTree(pid: number | undefined, force?: boolean): Promise<void>;
+export declare function currentProcessCollar(): ProcessCollar;
+export declare function spawnDetachedProcess(input: DetachedProcessInput): Promise<ProcessCollar>;
+export declare function probeProcessTree(collar: ProcessCollar): ProcessTreeProbe;
+export declare function putDownProcessTree(collar: ProcessCollar): Promise<PutDownEvidence>;
+export declare function runProcess(input: ProcessInput): Promise<ProcessOutcome>;
+export declare function runProcessToExit(input: ProcessLaunch): Promise<ProcessOutcome>;
+export {};

package/build/src/runtime/proc/run.js

@@ -0,0 +1,200 @@
+import { spawn, spawnSync } from "node:child_process";
+import { closeSync, openSync } from "node:fs";
+const TERMINATION_GRACE_MS = 250;
+const STREAM_TAIL_BYTES = 16 * 1024;
+function tailCapture(limit) {
+    const bytes = Buffer.allocUnsafe(limit);
+    let total = 0;
+    let cursor = 0;
+    return {
+        append(chunk) {
+            if (chunk.length >= limit) {
+                chunk.copy(bytes, 0, chunk.length - limit);
+                total += chunk.length;
+                cursor = 0;
+                return;
+            }
+            const first = Math.min(chunk.length, limit - cursor);
+            chunk.copy(bytes, cursor, 0, first);
+            if (first < chunk.length)
+                chunk.copy(bytes, 0, first);
+            total += chunk.length;
+            cursor = (cursor + chunk.length) % limit;
+        },
+        result() {
+            const size = Math.min(total, limit);
+            const start = total > limit ? cursor : 0;
+            const value = start === 0
+                ? bytes.subarray(0, size)
+                : Buffer.concat([bytes.subarray(start), bytes.subarray(0, start)]);
+            return { text: value.toString("utf8"), truncated: total > limit };
+        },
+    };
+}
+function wait(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+function ignoreMissingProcess(error) {
+    if (error.code !== "ESRCH")
+        throw error;
+}
+function terminateWindowsTree(pid) {
+    return new Promise((resolve) => {
+        const taskkill = spawn("taskkill", ["/PID", String(pid), "/T", "/F"], {
+            stdio: "ignore",
+            windowsHide: true,
+        });
+        taskkill.once("error", resolve);
+        taskkill.once("close", resolve);
+    });
+}
+export async function terminateProcessTree(pid, force = false) {
+    if (pid === undefined)
+        return;
+    if (process.platform === "win32") {
+        await terminateWindowsTree(pid);
+        return;
+    }
+    if (force) {
+        try {
+            process.kill(-pid, "SIGKILL");
+        }
+        catch (error) {
+            ignoreMissingProcess(error);
+        }
+        return;
+    }
+    try {
+        process.kill(-pid, "SIGTERM");
+    }
+    catch (error) {
+        ignoreMissingProcess(error);
+        return;
+    }
+    await wait(TERMINATION_GRACE_MS);
+    try {
+        process.kill(-pid, "SIGKILL");
+    }
+    catch (error) {
+        ignoreMissingProcess(error);
+    }
+}
+function processStartToken(pid) {
+    const command = process.platform === "win32"
+        ? ["powershell.exe", "-NoProfile", "-Command", `(Get-CimInstance Win32_Process -Filter \"ProcessId=${pid}\").CreationDate`]
+        : ["ps", "-o", "lstart=", "-p", String(pid)];
+    const result = spawnSync(command[0], command.slice(1), { encoding: "utf8", windowsHide: true });
+    const token = result.status === 0 ? result.stdout.trim() : "";
+    return token.length === 0 ? null : token;
+}
+export function currentProcessCollar() {
+    const spawnedAt = processStartToken(process.pid);
+    if (spawnedAt === null)
+        throw new Error(`cannot read process start identity for ${process.pid}`);
+    return { pid: process.pid, processGroup: process.pid, spawnedAt };
+}
+export async function spawnDetachedProcess(input) {
+    const log = openSync(input.log, "a");
+    try {
+        const child = spawn(input.argv[0], input.argv.slice(1), {
+            cwd: input.cwd,
+            env: input.env,
+            detached: true,
+            stdio: ["ignore", log, log],
+            windowsHide: true,
+        });
+        await new Promise((resolve, reject) => {
+            child.once("spawn", resolve);
+            child.once("error", reject);
+        });
+        if (child.pid === undefined)
+            throw new Error("detached process spawned without a pid");
+        const spawnedAt = processStartToken(child.pid);
+        if (spawnedAt === null)
+            throw new Error(`cannot read process start identity for ${child.pid}`);
+        child.unref();
+        return { pid: child.pid, processGroup: child.pid, spawnedAt };
+    }
+    finally {
+        closeSync(log);
+    }
+}
+export function probeProcessTree(collar) {
+    try {
+        process.kill(process.platform === "win32" ? collar.pid : -collar.processGroup, 0);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ESRCH")
+            return { kind: "gone" };
+        return { kind: "unverifiable", diagnostic: error instanceof Error ? error.message : String(error) };
+    }
+    const current = processStartToken(collar.pid);
+    if (current === null && process.platform !== "win32")
+        return { kind: "alive" };
+    if (current === collar.spawnedAt)
+        return { kind: "alive" };
+    return { kind: "unverifiable", diagnostic: `process ${collar.pid} no longer matches its recorded start identity` };
+}
+export async function putDownProcessTree(collar) {
+    const before = probeProcessTree(collar);
+    if (before.kind === "gone")
+        return "already-dead";
+    if (before.kind === "unverifiable")
+        return "unavailable";
+    await terminateProcessTree(collar.pid);
+    const after = probeProcessTree(collar);
+    if (after.kind === "gone")
+        return "killed";
+    return after.kind === "alive" ? "alive-after-sigkill" : "unavailable";
+}
+async function executeProcess(input, timeoutMs) {
+    const child = spawn(input.argv[0], input.argv.slice(1), {
+        cwd: input.cwd,
+        env: input.env,
+        detached: true,
+        stdio: ["ignore", "pipe", "pipe"],
+        windowsHide: true,
+    });
+    const stdout = tailCapture(STREAM_TAIL_BYTES);
+    const stderr = tailCapture(STREAM_TAIL_BYTES);
+    child.stdout.on("data", (chunk) => stdout.append(chunk));
+    child.stderr.on("data", (chunk) => stderr.append(chunk));
+    let timedOut = false;
+    let termination;
+    const requestStop = () => {
+        if (timedOut)
+            return;
+        timedOut = true;
+        termination = terminateProcessTree(child.pid);
+    };
+    const timeout = timeoutMs === undefined ? undefined : setTimeout(requestStop, timeoutMs);
+    const terminal = await new Promise((resolve) => {
+        child.once("close", (code) => resolve({ kind: "closed", code }));
+        child.once("error", (error) => resolve({ kind: "spawn-error", error }));
+    });
+    if (timeout !== undefined)
+        clearTimeout(timeout);
+    await termination;
+    if (terminal.kind === "spawn-error")
+        return { kind: "spawn-error", diagnostic: terminal.error.message };
+    if (timedOut)
+        return { kind: "timeout" };
+    if (terminal.code === null)
+        return { kind: "unknown-exit" };
+    const capturedStdout = stdout.result();
+    const capturedStderr = stderr.result();
+    return {
+        kind: "terminal",
+        code: terminal.code,
+        stdout: capturedStdout.text,
+        stderr: capturedStderr.text,
+        truncated: capturedStdout.truncated || capturedStderr.truncated,
+    };
+}
+export function runProcess(input) {
+    return executeProcess(input, input.timeoutMs);
+}
+export function runProcessToExit(input) {
+    return executeProcess(input, undefined);
+}

package/build/src/settings.d.ts

@@ -0,0 +1,45 @@
+export type SettingsScope = "project" | "user";
+export type SettingsScopeState = Readonly<{
+    kind: "absent";
+    path?: string;
+}> | Readonly<{
+    kind: "failed";
+    path: string;
+    diagnostic: string;
+}> | Readonly<{
+    kind: "read";
+    path: string;
+    namespaces: readonly string[];
+}>;
+export type SettingsEntry = Readonly<{
+    name: string;
+    value: unknown;
+    source: SettingsScope;
+    shadows: boolean;
+}>;
+export type SettingsNamespaceFailure = Readonly<{
+    scope: SettingsScope;
+    diagnostic: string;
+}>;
+export type SettingsNamespaceView = Readonly<{
+    kind: "read";
+    name: string;
+    entries: readonly SettingsEntry[];
+}> | Readonly<{
+    kind: "failed";
+    name: string;
+    entries: readonly SettingsEntry[];
+    failures: readonly SettingsNamespaceFailure[];
+}>;
+export type Settings = Readonly<{
+    scopes: Readonly<{
+        project: SettingsScopeState;
+        user: SettingsScopeState;
+    }>;
+    namespace(name: string): SettingsNamespaceView;
+}>;
+export type SettingsInput = Readonly<{
+    root?: string;
+    home?: string;
+}>;
+export declare function settings(input?: SettingsInput): Settings;

package/build/src/settings.js

@@ -0,0 +1,99 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function freezeJson(value) {
+    if (Array.isArray(value)) {
+        for (const item of value)
+            freezeJson(item);
+        return Object.freeze(value);
+    }
+    if (object(value)) {
+        for (const item of Object.values(value))
+            freezeJson(item);
+        return Object.freeze(value);
+    }
+    return value;
+}
+function bounded(error) {
+    return (error instanceof Error ? error.message : String(error)).slice(0, 500);
+}
+function readScope(path) {
+    let bytes;
+    try {
+        bytes = readFileSync(path, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { state: { kind: "absent", path } };
+        return { state: { kind: "failed", path, diagnostic: bounded(error) } };
+    }
+    try {
+        const decoded = JSON.parse(bytes);
+        if (!object(decoded))
+            throw new TypeError("settings root must be an object");
+        const root = freezeJson(decoded);
+        return { state: { kind: "read", path, namespaces: Object.freeze(Object.keys(root).sort()) }, root };
+    }
+    catch (error) {
+        return { state: { kind: "failed", path, diagnostic: bounded(error) } };
+    }
+}
+function namespaceEntries(name, scope, loaded) {
+    if (loaded.state.kind === "failed") {
+        return { entries: [], failure: { scope, diagnostic: loaded.state.diagnostic } };
+    }
+    const value = loaded.root?.[name];
+    if (value === undefined)
+        return { entries: [] };
+    if (!object(value)) {
+        return { entries: [], failure: { scope, diagnostic: `${name} must be an object of named values` } };
+    }
+    return {
+        entries: Object.keys(value).sort().map((entryName) => ({
+            name: entryName,
+            value: value[entryName],
+            source: scope,
+            shadows: false,
+        })),
+    };
+}
+export function settings(input = {}) {
+    if (!object(input))
+        throw new TypeError("settings input must be an object");
+    if (input.root !== undefined && (typeof input.root !== "string" || input.root.trim().length === 0)) {
+        throw new TypeError("settings root must be a nonblank string");
+    }
+    if (input.home !== undefined && (typeof input.home !== "string" || input.home.trim().length === 0)) {
+        throw new TypeError("settings home must be a nonblank string");
+    }
+    const home = resolve(input.home ?? join(homedir(), ".keiyaku"));
+    const user = readScope(join(home, "settings.json"));
+    const project = input.root === undefined
+        ? { state: { kind: "absent" } }
+        : readScope(join(resolve(input.root), ".keiyaku", "settings.json"));
+    return Object.freeze({
+        scopes: Object.freeze({ project: project.state, user: user.state }),
+        namespace(name) {
+            if (typeof name !== "string" || name.trim().length === 0)
+                throw new TypeError("settings namespace must be nonblank");
+            const fromUser = namespaceEntries(name, "user", user);
+            const fromProject = namespaceEntries(name, "project", project);
+            const userByName = new Map(fromUser.entries.map((entry) => [entry.name, entry]));
+            const projectByName = new Map(fromProject.entries.map((entry) => [entry.name, entry]));
+            const names = [...new Set([...userByName.keys(), ...projectByName.keys()])].sort();
+            const entries = Object.freeze(names.map((entryName) => {
+                const higher = projectByName.get(entryName);
+                if (higher !== undefined)
+                    return Object.freeze({ ...higher, shadows: userByName.has(entryName) });
+                return userByName.get(entryName);
+            }));
+            const failures = Object.freeze([fromUser.failure, fromProject.failure].filter((failure) => failure !== undefined));
+            return failures.length === 0
+                ? Object.freeze({ kind: "read", name, entries })
+                : Object.freeze({ kind: "failed", name, entries, failures });
+        },
+    });
+}