@astrosheep/keiyaku 4.0.0 → 4.0.2

package/build/src/core/facts/codec.js

@@ -39,6 +39,11 @@ function stringValue(value, path, nonblank = true) {
     }
     return value;
 }
+function booleanValue(value, path) {
+    if (typeof value !== "boolean")
+        fail(path, "expected a boolean");
+    return value;
+}
 function brandedValue(value, path, brand) {
     const text = stringValue(value, path);
     try {
@@ -156,11 +161,25 @@ function validateData(kind, value) {
         }
         case "deliver": {
             const object = requireRecord(value, path);
-            requireKeys(object, ["expectedPredecessor", "candidate", "deliveryPatchId"], path);
+            requireKeys(object, ["tenderSnapshot", "integration", "method", "policy"], path);
+            const integration = requireRecord(object.integration, `${path}.integration`);
+            requireKeys(integration, ["predecessor", "snapshot", "changeId"], `${path}.integration`);
+            const method = stringValue(object.method, `${path}.method`);
+            if (method !== "squash")
+                fail(`${path}.method`, "unknown merge method");
+            const policy = requireRecord(object.policy, `${path}.policy`);
+            requireKeys(policy, ["requireBranchesToBeUpToDate"], `${path}.policy`);
             return {
-                expectedPredecessor: brandedValue(object.expectedPredecessor, `${path}.expectedPredecessor`, snapshotId),
-                candidate: brandedValue(object.candidate, `${path}.candidate`, snapshotId),
-                deliveryPatchId: brandedValue(object.deliveryPatchId, `${path}.deliveryPatchId`, changeId),
+                tenderSnapshot: brandedValue(object.tenderSnapshot, `${path}.tenderSnapshot`, snapshotId),
+                integration: {
+                    predecessor: brandedValue(integration.predecessor, `${path}.integration.predecessor`, snapshotId),
+                    snapshot: brandedValue(integration.snapshot, `${path}.integration.snapshot`, snapshotId),
+                    changeId: brandedValue(integration.changeId, `${path}.integration.changeId`, changeId),
+                },
+                method,
+                policy: {
+                    requireBranchesToBeUpToDate: booleanValue(policy.requireBranchesToBeUpToDate, `${path}.policy.requireBranchesToBeUpToDate`),
+                },
             };
         }
         case "attestation":

package/build/src/core/facts/eligibility.d.ts

@@ -1,16 +1,7 @@
-import type { Offer } from "./offer.js";
 import { type ContractsObservation } from "./observation.js";
-import type { ContractId, EntryUlid } from "./types.js";
+import type { ContractId } from "./types.js";
 type EligibilityObservation = ContractsObservation;
-type EligibilityAttempt = Readonly<{
-    entryUlids: readonly EntryUlid[];
-}>;
-type PrerequisiteStatus = "unknown" | "pending" | "claimed";
-/** Resolve prerequisite existence and eligibility from one decision snapshot. */
-export declare function prerequisiteStatus(prerequisites: readonly ContractId[], observation: EligibilityObservation, offeredClaims?: ReadonlySet<ContractId>): PrerequisiteStatus;
 /** Decide whether resulting prerequisites reach the amended contract. */
 export declare function prerequisitesReach(contract: ContractId, prerequisites: readonly ContractId[], observation: EligibilityObservation): boolean;
 export declare function samePrerequisites(left: readonly ContractId[], right: readonly ContractId[]): boolean;
-/** Append bounds made eligible by a claimed offer from its full snapshot. */
-export declare function placeEligibleBounds(offer: Offer, observation: EligibilityObservation, attempt: EligibilityAttempt): Offer;
 export {};

package/build/src/core/facts/eligibility.js

@@ -1,16 +1,4 @@
 import { contractState } from "./observation.js";
-/** Resolve prerequisite existence and eligibility from one decision snapshot. */
-export function prerequisiteStatus(prerequisites, observation, offeredClaims) {
-    let pending = false;
-    for (const dependency of prerequisites) {
-        const state = contractState(observation, dependency);
-        if (state === null)
-            return "unknown";
-        if (state.terminal?.kind !== "claimed" && offeredClaims?.has(dependency) !== true)
-            pending = true;
-    }
-    return pending ? "pending" : "claimed";
-}
 /** Decide whether resulting prerequisites reach the amended contract. */
 export function prerequisitesReach(contract, prerequisites, observation) {
     const pending = [...prerequisites];
@@ -36,40 +24,3 @@ export function samePrerequisites(left, right) {
         return false;
     return left.every((id, index) => id === right[index]);
 }
-/** Append bounds made eligible by a claimed offer from its full snapshot. */
-export function placeEligibleBounds(offer, observation, attempt) {
-    const claimedEntry = offer.facts[0]?.entries[0];
-    if (offer.facts.length !== 1 || offer.facts[0]?.entries.length !== 1 || claimedEntry?.kind !== "claimed") {
-        throw new Error("eligible-bound placement requires exactly one claimed fact");
-    }
-    const claimed = new Set([claimedEntry.contract]);
-    const used = new Set([claimedEntry.entry]);
-    const available = attempt.entryUlids.filter((entry) => !used.has(entry));
-    let availableIndex = 0;
-    const additions = [];
-    for (const id of observation.keys()) {
-        const state = contractState(observation, id);
-        if (!state || state.bound || state.terminal)
-            continue;
-        if (prerequisiteStatus(state.terms.after, observation, claimed) !== "claimed")
-            continue;
-        const entry = available[availableIndex];
-        if (entry === undefined)
-            throw new Error("placement attempt lacks an entry ULID for an eligible contract");
-        availableIndex += 1;
-        additions.push({
-            contractId: id,
-            expectedHead: state.head,
-            entries: [{
-                    v: 1,
-                    kind: "bound",
-                    contract: id,
-                    entry,
-                    at: claimedEntry.at,
-                    ...(claimedEntry.actor === undefined ? {} : { actor: claimedEntry.actor }),
-                    data: {},
-                }],
-        });
-    }
-    return additions.length === 0 ? offer : { ...offer, facts: [...additions, ...offer.facts] };
-}

package/build/src/core/facts/fold.js

@@ -1,4 +1,3 @@
-import { samePrerequisites } from "./eligibility.js";
 import { gatesSatisfied } from "./gate.js";
 import { AuthorityCorruptionError } from "./errors.js";
 function foldError(message) {
@@ -47,12 +46,8 @@ function foldEntry(state, entry, attestations) {
     switch (entry.kind) {
         case "bind":
             foldError("bind may appear only once");
-        case "amend": {
-            if (state.bound !== null && !samePrerequisites(state.terms.after, entry.data.after)) {
-                foldError("cannot change after once prerequisites are consumed");
-            }
+        case "amend":
             return { ...state, terms: cloneTerms(entry.data) };
-        }
         case "bound":
             if (state.bound !== null)
                 foldError("bound may appear only once");

package/build/src/core/facts/gate.d.ts

@@ -3,6 +3,7 @@ export type GateCurrent = Readonly<{
     kind: "attested";
     verdict: "satisfied" | "unsatisfied";
     summary?: string;
+    at: string;
 }> | Readonly<{
     kind: "stale";
     priorVerdict: "satisfied" | "unsatisfied";

package/build/src/core/facts/gate.js

@@ -37,6 +37,7 @@ export function gateReports(state) {
                     kind: "attested",
                     verdict: attestation.data.verdict,
                     ...(attestation.data.summary === undefined ? {} : { summary: attestation.data.summary }),
+                    at: attestation.at,
                 },
             };
         }

package/build/src/core/facts/observation.d.ts

@@ -1,8 +1,11 @@
 import type { ContractId, ContractState, DocumentKey } from "./types.js";
 /** The complete state projection consumed by one pure pact decision. */
 export type ContractsObservation = ReadonlyMap<ContractId, ContractState | null>;
+export type PrerequisiteStatus = "unknown" | "pending" | "claimed";
 /** Read one requested identity; a missing key violates the observation contract. */
 export declare function contractState(observation: ContractsObservation, contract: ContractId): ContractState | null;
+/** Project prerequisite existence and terminal satisfaction from one observation. */
+export declare function prerequisiteStatus(prerequisites: readonly ContractId[], observation: ContractsObservation): PrerequisiteStatus;
 export type ActiveContractRefusal = Readonly<{
     kind: "contract-missing" | "terminal";
     contractId: ContractId;

package/build/src/core/facts/observation.js

@@ -9,6 +9,18 @@ export function contractState(observation, contract) {
     }
     return state;
 }
+/** Project prerequisite existence and terminal satisfaction from one observation. */
+export function prerequisiteStatus(prerequisites, observation) {
+    let pending = false;
+    for (const dependency of prerequisites) {
+        const state = contractState(observation, dependency);
+        if (state === null)
+            return "unknown";
+        if (state.terminal?.kind !== "claimed")
+            pending = true;
+    }
+    return pending ? "pending" : "claimed";
+}
 /** The single lifecycle guard shared by every operation on an existing contract. */
 export function activeContract(observation, contract) {
     const state = contractState(observation, contract);

package/build/src/core/facts/types.d.ts

@@ -74,9 +74,16 @@ export type BindData = Readonly<{
 export type AmendData = ContractTerms;
 export type BoundData = Readonly<Record<string, never>>;
 export type DeliverData = Readonly<{
-    expectedPredecessor: SnapshotId;
-    candidate: SnapshotId;
-    deliveryPatchId: ChangeId;
+    tenderSnapshot: SnapshotId;
+    integration: Readonly<{
+        predecessor: SnapshotId;
+        snapshot: SnapshotId;
+        changeId: ChangeId;
+    }>;
+    method: "squash";
+    policy: Readonly<{
+        requireBranchesToBeUpToDate: boolean;
+    }>;
 }>;
 export type AttestationData = Readonly<{
     gate: Gate;

package/build/src/core/subject.js

@@ -69,8 +69,8 @@ function currentKeys(state) {
         encodeKey({ kind: "document", value: state.terms.document.key }),
         ...state.terms.segments.map((value) => encodeKey({ kind: "segment", value })),
         ...(state.delivery === null ? [] : [
-            encodeKey({ kind: "snapshot", value: state.delivery.data.candidate }),
-            encodeKey({ kind: "change", value: state.delivery.data.deliveryPatchId }),
+            encodeKey({ kind: "snapshot", value: state.delivery.data.integration.snapshot }),
+            encodeKey({ kind: "change", value: state.delivery.data.integration.changeId }),
         ]),
     ]);
 }

package/build/src/core/verbs/amend.d.ts

@@ -8,7 +8,7 @@ export type AmendInput<Failure = never> = Readonly<{
     preparation?: Preparation<AmendData, Failure>;
 }>;
 export type AmendRefusal = Readonly<{
-    kind: "contract-missing" | "terminal" | "terms-moved" | "prerequisites-already-consumed" | "unknown-prerequisite" | "cyclic-prerequisite";
+    kind: "contract-missing" | "terminal" | "terms-moved" | "unknown-prerequisite" | "cyclic-prerequisite";
     contractId: ContractId;
 }>;
 export declare function decideAmend<Failure>({ input, attempt, observation }: DecideInput<AmendInput<Failure>>): OfferDecision<AmendRefusal | Failure>;

package/build/src/core/verbs/amend.js

@@ -1,5 +1,5 @@
-import { prerequisiteStatus, prerequisitesReach, samePrerequisites } from "../facts/eligibility.js";
-import { activeContract } from "../facts/observation.js";
+import { prerequisitesReach, samePrerequisites } from "../facts/eligibility.js";
+import { activeContract, prerequisiteStatus } from "../facts/observation.js";
 export function decideAmend({ input, attempt, observation }) {
     const id = input.contractId;
     const current = activeContract(observation, id);
@@ -21,9 +21,6 @@ export function decideAmend({ input, attempt, observation }) {
     if (input.preparation.kind === "refused")
         return { kind: "refused", refusal: input.preparation.refusal };
     const { data } = input.preparation;
-    if (current.bound !== null && !samePrerequisites(current.terms.after, data.after)) {
-        return { kind: "refused", refusal: { kind: "prerequisites-already-consumed", contractId: id } };
-    }
     const prerequisites = prerequisiteStatus(data.after, observation);
     if (prerequisites === "unknown") {
         return { kind: "refused", refusal: { kind: "unknown-prerequisite", contractId: id } };
@@ -40,17 +37,5 @@ export function decideAmend({ input, attempt, observation }) {
         ...(input.actor === undefined ? {} : { actor: input.actor }),
         data,
     };
-    const entries = [entry];
-    if (current.bound === null && prerequisites === "claimed") {
-        entries.push({
-            v: 1,
-            kind: "bound",
-            contract: id,
-            entry: attempt.entryUlids[1],
-            at: input.at,
-            ...(input.actor === undefined ? {} : { actor: input.actor }),
-            data: {},
-        });
-    }
-    return { kind: "offer", offer: { facts: [{ contractId: id, expectedHead: current.head, entries }] } };
+    return { kind: "offer", offer: { facts: [{ contractId: id, expectedHead: current.head, entries: [entry] }] } };
 }

package/build/src/core/verbs/bind.js

@@ -1,5 +1,4 @@
-import { prerequisiteStatus } from "../facts/eligibility.js";
-import { contractState } from "../facts/observation.js";
+import { contractState, prerequisiteStatus } from "../facts/observation.js";
 export function decideBind({ input, attempt, observation }) {
     const id = input.contractId;
     const current = contractState(observation, id);
@@ -23,18 +22,5 @@ export function decideBind({ input, attempt, observation }) {
         ...(input.actor === undefined ? {} : { actor: input.actor }),
         data,
     };
-    const entries = [bind];
-    if (prerequisites === "claimed") {
-        const bound = {
-            v: 1,
-            kind: "bound",
-            contract: id,
-            entry: attempt.entryUlids[1],
-            at: input.at,
-            ...(input.actor === undefined ? {} : { actor: input.actor }),
-            data: {},
-        };
-        entries.push(bound);
-    }
-    return { kind: "offer", offer: { facts: [{ contractId: id, expectedHead: null, entries }] } };
+    return { kind: "offer", offer: { facts: [{ contractId: id, expectedHead: null, entries: [bind] }] } };
 }

package/build/src/core/verbs/deliver.d.ts

@@ -7,7 +7,7 @@ export type DeliverInput<Failure = never> = Readonly<{
     preparation: StampedPreparation<DeliverData, Failure>;
 }>;
 export type DeliverRefusal = Readonly<{
-    kind: "contract-missing" | "not-bound" | "terminal" | "document-moved";
+    kind: "contract-missing" | "terminal" | "document-moved";
     contractId: ContractId;
 }>;
 export declare function decideDeliver<Failure>({ input, attempt, observation, }: DecideInput<DeliverInput<Failure>>): OfferDecision<DeliverRefusal | Failure>;

package/build/src/core/verbs/deliver.js

@@ -3,8 +3,6 @@ export function decideDeliver({ input, attempt, observation, }) {
     const state = activeContract(observation, input.contractId);
     if ("kind" in state)
         return { kind: "refused", refusal: state };
-    if (state.bound === null)
-        return { kind: "refused", refusal: { kind: "not-bound", contractId: input.contractId } };
     if (input.preparation.kind === "unavailable") {
         throw new Error("existing contract requires a stamped delivery preparation");
     }
@@ -13,14 +11,26 @@ export function decideDeliver({ input, attempt, observation, }) {
     }
     if (input.preparation.kind === "refused")
         return { kind: "refused", refusal: input.preparation.refusal };
+    const entries = [];
+    if (state.bound === null)
+        entries.push({
+            v: 1,
+            kind: "bound",
+            contract: input.contractId,
+            entry: attempt.entryUlids[0],
+            at: input.at,
+            ...(input.actor === undefined ? {} : { actor: input.actor }),
+            data: {},
+        });
     const deliver = {
         v: 1,
         kind: "deliver",
         contract: input.contractId,
-        entry: attempt.entryUlids[0],
+        entry: attempt.entryUlids[state.bound === null ? 1 : 0],
         at: input.at,
         ...(input.actor === undefined ? {} : { actor: input.actor }),
         data: input.preparation.data,
     };
-    return { kind: "offer", offer: { facts: [{ contractId: input.contractId, expectedHead: state.head, entries: [deliver] }] } };
+    entries.push(deliver);
+    return { kind: "offer", offer: { facts: [{ contractId: input.contractId, expectedHead: state.head, entries }] } };
 }

package/build/src/core/verbs/placement.d.ts

@@ -6,7 +6,7 @@ type PlacementInput = Readonly<{
     at: string;
 }>;
 export type PlacementRefusal = Readonly<{
-    kind: "contract-missing" | "delivery-missing" | "terminal" | "gates-unsatisfied";
+    kind: "contract-missing" | "delivery-missing" | "terminal" | "prerequisites-unsatisfied" | "gates-unsatisfied";
     contractId: ContractId;
 }>;
 export declare function decidePlacement({ input, attempt, observation }: DecideInput<PlacementInput>): OfferDecision<PlacementRefusal>;

package/build/src/core/verbs/placement.js

@@ -1,6 +1,5 @@
 import { gatesSatisfied } from "../facts/gate.js";
-import { placeEligibleBounds } from "../facts/eligibility.js";
-import { activeContract } from "../facts/observation.js";
+import { activeContract, prerequisiteStatus } from "../facts/observation.js";
 export function decidePlacement({ input, attempt, observation }) {
     const id = input.contractId;
     const current = activeContract(observation, id);
@@ -10,6 +9,9 @@ export function decidePlacement({ input, attempt, observation }) {
     if (!delivery) {
         return { kind: "refused", refusal: { kind: "delivery-missing", contractId: id } };
     }
+    if (prerequisiteStatus(current.terms.after, observation) !== "claimed") {
+        return { kind: "refused", refusal: { kind: "prerequisites-unsatisfied", contractId: id } };
+    }
     if (!gatesSatisfied(current)) {
         return { kind: "refused", refusal: { kind: "gates-unsatisfied", contractId: id } };
     }
@@ -22,21 +24,17 @@ export function decidePlacement({ input, attempt, observation }) {
         ...(input.actor === undefined ? {} : { actor: input.actor }),
         data: { delivery: delivery.entry },
     };
-    const offer = {
+    return {
         kind: "offer",
         offer: {
             facts: [{ contractId: id, expectedHead: current.head, entries: [claimed] }],
             ...(current.coordinates.target === undefined ? {} : {
                 target: {
                     target: current.coordinates.target,
-                    expectedOid: delivery.data.expectedPredecessor,
-                    newOid: delivery.data.candidate,
+                    expectedOid: delivery.data.integration.predecessor,
+                    newOid: delivery.data.integration.snapshot,
                 },
             }),
         },
     };
-    return {
-        ...offer,
-        offer: placeEligibleBounds(offer.offer, observation, attempt),
-    };
 }

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

@@ -1,6 +1,7 @@
 import { type ContractId } from "../core/facts/types.js";
 import { type AkuId } from "../akuma/identity.js";
 import { type GitRepository } from "../git/repository.js";
+import { type GitReadObservation } from "../git/read-observation.js";
 export type Dispatch = Readonly<{
     akuId: AkuId;
     contractId: ContractId;
@@ -22,10 +23,11 @@ export type DispatchPublication = Readonly<{
     kind: "failed";
     failure: DispatchFailure;
 }>;
-export declare function readDispatch(repository: GitRepository, value: AkuId): Dispatch | null;
-export declare function readDispatches(repository: GitRepository): readonly Dispatch[];
+export declare function readDispatch(repository: GitRepository, value: AkuId): Promise<Dispatch | null>;
+export declare function readDispatchesAt(observation: GitReadObservation): Promise<readonly Dispatch[]>;
+export declare function readDispatches(repository: GitRepository): Promise<readonly Dispatch[]>;
 export declare function publishDispatch(input: Readonly<{
     repository: GitRepository;
     akuId: AkuId;
     contractId: ContractId;
-}>): DispatchPublication;
+}>): Promise<DispatchPublication>;

package/build/src/dispatch/index.js

@@ -2,7 +2,8 @@ import { createHash } from "node:crypto";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { contractId } from "../core/facts/types.js";
 import { parseAkuId } from "../akuma/identity.js";
-import { GIT_FORMAT_BYTES, GIT_FORMAT_PATH, GIT_REF, readBlob, readGit, readGitPaths, updateGitTree, updateRefsAtomically, writeBlob, writeCommit, } from "../git/repository.js";
+import { GIT_FORMAT_BYTES, GIT_FORMAT_PATH, GIT_REF, readBlob, readGitPaths, updateGitTree, updateRefsAtomically, writeBlob, writeCommit, } from "../git/repository.js";
+import { withGitDecodeChannel, withGitReadObservation } from "../git/read-observation.js";
 const DISPATCH_ROOT = "dispatch";
 const DISPATCH_PREFIX = `${DISPATCH_ROOT}/`;
 const DISPATCH_SUFFIX = ".json";
@@ -63,25 +64,27 @@ function decode(path, bytes) {
     }
     return dispatch;
 }
-function dispatchFromSnapshot(repository, snapshot, akuId) {
+async function dispatchFromSnapshot(repository, snapshot, akuId) {
     const path = pathFor(akuId);
     const entry = snapshot.paths.get(path);
     if (entry === undefined)
         return null;
     if (entry.type !== "blob")
         corruption(`Dispatch path is not a blob: ${path}`);
-    return decode(path, readBlob(repository, entry.oid));
+    return decode(path, await readBlob(repository, entry.oid));
 }
-export function readDispatch(repository, value) {
+export async function readDispatch(repository, value) {
     const akuId = parseAkuId(value).id;
     const path = pathFor(akuId);
-    return dispatchFromSnapshot(repository, readGitPaths(repository, [path]), akuId);
+    return await dispatchFromSnapshot(repository, await readGitPaths(repository, [path]), akuId);
 }
-export function readDispatches(repository) {
-    const snapshot = readGit(repository);
+export async function readDispatchesAt(observation) {
+    const entries = [...observation.snapshot.paths]
+        .filter(([path, entry]) => path.startsWith(DISPATCH_PREFIX) && entry.type === "blob");
+    const blobs = await observation.readBlobs(entries.map(([, entry]) => entry.oid));
     const dispatches = [];
     const seen = new Set();
-    for (const [path, entry] of snapshot.paths) {
+    for (const [path, entry] of observation.snapshot.paths) {
         if (path === DISPATCH_ROOT)
             corruption(`Dispatch authority root is not a tree: ${path}`);
         if (!path.startsWith(DISPATCH_PREFIX))
@@ -90,7 +93,10 @@ export function readDispatches(repository) {
             corruption(`unexpected Dispatch authority path: ${path}`);
         if (entry.type !== "blob")
             corruption(`Dispatch path is not a blob: ${path}`);
-        const dispatch = decode(path, readBlob(repository, entry.oid));
+        const result = blobs.get(entry.oid);
+        if (result?.kind !== "present")
+            corruption(`missing Dispatch Git object: ${path}`);
+        const dispatch = decode(path, result.bytes);
         if (seen.has(dispatch.akuId))
             corruption(`duplicate Dispatch identity: ${dispatch.akuId}`);
         seen.add(dispatch.akuId);
@@ -98,8 +104,11 @@ export function readDispatches(repository) {
     }
     return dispatches.sort((left, right) => Buffer.compare(Buffer.from(left.akuId), Buffer.from(right.akuId)));
 }
-function observedPublication(repository, akuId, owner) {
-    const current = readDispatch(repository, akuId);
+export async function readDispatches(repository) {
+    return await withGitDecodeChannel(repository, (channel) => withGitReadObservation(repository, channel, readDispatchesAt));
+}
+async function observedPublication(repository, akuId, owner) {
+    const current = await readDispatch(repository, akuId);
     if (current === null)
         return null;
     return current.contractId === owner
@@ -109,14 +118,14 @@ function observedPublication(repository, akuId, owner) {
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
-export function publishDispatch(input) {
+export async function publishDispatch(input) {
     const akuId = parseAkuId(input.akuId).id;
     const owner = contractId(input.contractId);
     const intended = { akuId, contractId: owner, dispatchedAt: new Date().toISOString() };
     const path = pathFor(akuId);
     for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt += 1) {
-        const snapshot = readGitPaths(input.repository, [path]);
-        const current = dispatchFromSnapshot(input.repository, snapshot, akuId);
+        const snapshot = await readGitPaths(input.repository, [path]);
+        const current = await dispatchFromSnapshot(input.repository, snapshot, akuId);
         if (current !== null) {
             return current.contractId === owner
                 ? { kind: "dispatched", dispatch: current }
@@ -124,29 +133,29 @@ export function publishDispatch(input) {
         }
         const changes = new Map();
         if (snapshot.commit === null) {
-            changes.set(GIT_FORMAT_PATH, { oid: writeBlob(input.repository, GIT_FORMAT_BYTES) });
+            changes.set(GIT_FORMAT_PATH, { oid: await writeBlob(input.repository, GIT_FORMAT_BYTES) });
         }
-        changes.set(path, { oid: writeBlob(input.repository, bytesFor(intended)) });
-        const tree = updateGitTree(input.repository, snapshot.tree, changes);
-        const commit = writeCommit({
+        changes.set(path, { oid: await writeBlob(input.repository, bytesFor(intended)) });
+        const tree = await updateGitTree(input.repository, snapshot.tree, changes);
+        const commit = await writeCommit({
             repository: input.repository,
             tree,
             parent: snapshot.commit,
             message: `dispatch ${akuId}`,
             at: intended.dispatchedAt,
         });
-        const publication = updateRefsAtomically(input.repository, [{
+        const publication = await updateRefsAtomically(input.repository, [{
                 ref: GIT_REF,
                 newOid: commit,
                 expectedOid: snapshot.commit,
             }]);
         if (publication.kind === "published")
             return { kind: "dispatched", dispatch: intended };
-        const observed = observedPublication(input.repository, akuId, owner);
+        const observed = await observedPublication(input.repository, akuId, owner);
         if (observed !== null)
             return observed;
         if (publication.kind === "non-published") {
-            const fresh = readGitPaths(input.repository, [path]);
+            const fresh = await readGitPaths(input.repository, [path]);
             if (fresh.commit === snapshot.commit) {
                 return {
                     kind: "failed",

package/build/src/duration.d.ts

@@ -0,0 +1,10 @@
+export type DurationParseResult = Readonly<{
+    kind: "parsed";
+    milliseconds: number;
+}> | Readonly<{
+    kind: "invalid";
+}> | Readonly<{
+    kind: "overflow";
+}>;
+export declare function parseDuration(value: string): DurationParseResult;
+export declare function formatDuration(milliseconds: number): string;

package/build/src/duration.js

@@ -0,0 +1,22 @@
+const MULTIPLIERS = Object.freeze({
+    ms: 1n,
+    s: 1000n,
+    m: 60000n,
+    h: 3600000n,
+});
+export function parseDuration(value) {
+    const match = /^(0|[1-9][0-9]*)(ms|s|m|h)$/u.exec(value);
+    if (match === null)
+        return { kind: "invalid" };
+    const milliseconds = BigInt(match[1]) * MULTIPLIERS[match[2]];
+    if (milliseconds > BigInt(Number.MAX_SAFE_INTEGER))
+        return { kind: "overflow" };
+    return { kind: "parsed", milliseconds: Number(milliseconds) };
+}
+export function formatDuration(milliseconds) {
+    for (const [unit, multiplier] of [["h", 3_600_000], ["m", 60_000], ["s", 1_000]]) {
+        if (milliseconds >= multiplier && milliseconds % multiplier === 0)
+            return `${milliseconds / multiplier}${unit}`;
+    }
+    return `${milliseconds}ms`;
+}

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

@@ -1,6 +1,6 @@
 import type { Offer } from "../core/facts/offer.js";
 import type { GitAdmissionSnapshot } from "./observe.js";
-import { type GitRepository } from "./repository.js";
+import { type GitRepository, type GitRefAssertion } from "./repository.js";
 import { type ContractHead } from "../core/facts/types.js";
 type Accepted = Readonly<{
     kind: "accepted";
@@ -14,5 +14,5 @@ type Unknown = Readonly<{
     kind: "unknown";
 }>;
 export type Admission = Accepted | PublicationFailed | Unknown;
-export declare function admit(repository: GitRepository, offer: Offer, admission: GitAdmissionSnapshot): Admission;
+export declare function admit(repository: GitRepository, offer: Offer, admission: GitAdmissionSnapshot, assertions?: readonly GitRefAssertion[]): Promise<Admission>;
 export {};