@openlfcp/client 0.2.2 → 0.3.1

package/dist/identity/phases.d.ts

@@ -0,0 +1,75 @@
+import { type ControlRecordId, type Hash32, type PrincipalId, type ResourceId } from "@openlfcp/core";
+import { type CertificateChain, type ChainResult, type ControlRecord, type ControlState, type DeviceCertificatePayload } from "@openlfcp/wire";
+/**
+ * Phase states of a durable multi-record operation (IDENTITY-PROFILE-01
+ * §9.2). After a CONTROL_HEAD_MISMATCH or a restart the client synchronises
+ * the Resource and classifies each phase against the accepted chain; one
+ * rule applies per kind of phase, first match wins. These functions are
+ * pure: the same chain and the same intent give the same state on every
+ * installation.
+ */
+export type PhaseState = 
+/** Propose, or propose again on the new head. */
+"pending"
+/** The chain holds this installation's own record: continue with the next phase. */
+ | "committed-own"
+/** The effect exists by someone else's hand and the phase is idempotent: skip it. */
+ | "complete"
+/** The chain makes the phase impossible: the operation ends, nothing further is signed. */
+ | "superseded"
+/** The rotator test of §8.1 fails on the current head. */
+ | "awaiting-rotation"
+/** A KEY_EPOCH is committed whose DEK this client does not hold (§9.2). */
+ | "awaiting-key-holder";
+export type LinearChain = Extract<ChainResult, {
+    kind: "linear";
+}>;
+/** The Consume phase: `DEVICE_REVOKE {R, J, 3, digest}` (§5.3 step 5). */
+export declare function classifyConsume(state: ControlState, root: PrincipalId, pairing: PrincipalId, digest: Hash32): PhaseState;
+/** The Cancel phase of a pairing device: `DEVICE_REVOKE {R, J, 0}` (§5.3 step 9). */
+export declare function classifyCancel(state: ControlState, root: PrincipalId, pairing: PrincipalId): PhaseState;
+/**
+ * The Revoke phase `(R, D)` with a reason in {0, 1, 2}: a revocation with
+ * another reason by anyone is `complete` (the operation continues with the
+ * rotation test), never `committed-own` or `superseded` (§9.2).
+ */
+export declare function classifyRevoke(state: ControlState, root: PrincipalId, device: PrincipalId): PhaseState;
+/** Whether a certificate's scope admits `resource` (W §7.3 rule 5; kind 0 has no scope). */
+export declare function certificateInScope(leaf: DeviceCertificatePayload, resource: ResourceId): boolean;
+/** The accepted DEVICE_GRANT record whose leaf is `leafId`, if any (the latest). */
+export declare function grantRecordOf(chain: LinearChain, leafId: Hash32): ControlRecord | undefined;
+export interface RegisterPhase {
+    readonly root: PrincipalId;
+    /** The certificate chain the phase proposes (leaf = the device). */
+    readonly chain: CertificateChain;
+    /** Phase 2 of a pairing approval: a binding with another leaf is `superseded`. */
+    readonly pairingPhase2?: boolean;
+    /** Whether a record ID (hex) is one this installation sent for the phase (§9.1: persisted before sending). */
+    readonly isOwnRecord: (recordIdHex: string) => boolean;
+}
+/**
+ * The Register or re-certify phase of leaf `D` with certificate `c`
+ * (`DEVICE_GRANT`, §9.2). A matching effect (same leaf certificate ID,
+ * `registered` agreeing with `c`'s scope here) is `committed-own` when this
+ * installation's record produced it, else `complete`; it is never
+ * re-proposed as a new transition (W §17.4 rule 5).
+ */
+export declare function classifyRegister(chain: LinearChain, phase: RegisterPhase): PhaseState;
+/** The control sequence of the record `id` on `chain`, if it is there. */
+export declare function recordSeq(chain: LinearChain, id: ControlRecordId | Uint8Array): bigint | undefined;
+/**
+ * The Rotate phase after a revocation at control sequence `revokedAt`
+ * (§9.2, §9.3): `complete` when a KEY_EPOCH is accepted after it;
+ * `awaiting-rotation` when the rotator test of §8.1 fails on the current
+ * head; otherwise `pending` (the KEY_EPOCH is rebuilt, never re-sent).
+ */
+export declare function classifyRotate(chain: LinearChain, revokedAt: bigint, rotator: boolean): PhaseState;
+/** Whether a KEY_EPOCH is accepted at a control sequence greater than `seq` (§8.4: the mark clears). */
+export declare function keyEpochAfter(chain: LinearChain, seq: bigint): boolean;
+/**
+ * A Package phase `(resource, epoch, recipient)` (§9.2): never superseded;
+ * `complete` when the ledger records it; a recipient that is no longer a
+ * reader at the head is skipped.
+ */
+export declare function classifyPackage(ledgered: boolean, readerAtHead: boolean): PhaseState | "skipped";
+//# sourceMappingURL=phases.d.ts.map

package/dist/identity/phases.js

@@ -0,0 +1,104 @@
+import { bytesEqual, toHex, } from "@openlfcp/core";
+import { DEVICE_KIND, revocationOf, } from "@openlfcp/wire";
+const REASON_CONSUMED = 3n;
+/** The Consume phase: `DEVICE_REVOKE {R, J, 3, digest}` (§5.3 step 5). */
+export function classifyConsume(state, root, pairing, digest) {
+    const r = revocationOf(state, root, pairing);
+    if (r === undefined)
+        return "pending";
+    return r.reason === REASON_CONSUMED && r.approval !== null && bytesEqual(r.approval, digest)
+        ? "committed-own"
+        : "superseded";
+}
+/** The Cancel phase of a pairing device: `DEVICE_REVOKE {R, J, 0}` (§5.3 step 9). */
+export function classifyCancel(state, root, pairing) {
+    const r = revocationOf(state, root, pairing);
+    if (r === undefined)
+        return "pending";
+    return r.reason === REASON_CONSUMED ? "superseded" : "complete";
+}
+/**
+ * The Revoke phase `(R, D)` with a reason in {0, 1, 2}: a revocation with
+ * another reason by anyone is `complete` (the operation continues with the
+ * rotation test), never `committed-own` or `superseded` (§9.2).
+ */
+export function classifyRevoke(state, root, device) {
+    const r = revocationOf(state, root, device);
+    if (r === undefined)
+        return "pending";
+    return r.reason === REASON_CONSUMED ? "superseded" : "complete";
+}
+/** Whether a certificate's scope admits `resource` (W §7.3 rule 5; kind 0 has no scope). */
+export function certificateInScope(leaf, resource) {
+    return leaf.kind === DEVICE_KIND.PERSONAL || leaf.scope.some((r) => bytesEqual(r, resource));
+}
+const isGrantOf = (record, leafId) => record.body.type === "DEVICE_GRANT" && bytesEqual(record.body.chain.leaf.id, leafId);
+/** The accepted DEVICE_GRANT record whose leaf is `leafId`, if any (the latest). */
+export function grantRecordOf(chain, leafId) {
+    for (let i = chain.records.length - 1; i >= 0; i--) {
+        const r = chain.records[i];
+        if (isGrantOf(r, leafId))
+            return r;
+    }
+    return undefined;
+}
+/**
+ * The Register or re-certify phase of leaf `D` with certificate `c`
+ * (`DEVICE_GRANT`, §9.2). A matching effect (same leaf certificate ID,
+ * `registered` agreeing with `c`'s scope here) is `committed-own` when this
+ * installation's record produced it, else `complete`; it is never
+ * re-proposed as a new transition (W §17.4 rule 5).
+ */
+export function classifyRegister(chain, phase) {
+    const state = chain.state;
+    const leaf = phase.chain.leaf;
+    const device = leaf.payload.device.principalId;
+    if (revocationOf(state, phase.root, device) !== undefined)
+        return "superseded";
+    if (phase.chain.issuers.some((e) => revocationOf(state, phase.root, e) !== undefined))
+        return "superseded";
+    const d = state.devices.get(toHex(device));
+    if (d?.leafId !== null && d?.leafId !== undefined) {
+        if (bytesEqual(d.leafId, leaf.id) &&
+            d.registered === certificateInScope(leaf.payload, state.resourceId)) {
+            const record = grantRecordOf(chain, leaf.id);
+            return record !== undefined && phase.isOwnRecord(toHex(record.signed.id))
+                ? "committed-own"
+                : "complete";
+        }
+        if (!bytesEqual(d.leafId, leaf.id) && phase.pairingPhase2 === true)
+            return "superseded";
+    }
+    return "pending";
+}
+/** The control sequence of the record `id` on `chain`, if it is there. */
+export function recordSeq(chain, id) {
+    const hex = toHex(id);
+    return chain.records.find((r) => toHex(r.signed.id) === hex)?.payload.controlSeq;
+}
+/**
+ * The Rotate phase after a revocation at control sequence `revokedAt`
+ * (§9.2, §9.3): `complete` when a KEY_EPOCH is accepted after it;
+ * `awaiting-rotation` when the rotator test of §8.1 fails on the current
+ * head; otherwise `pending` (the KEY_EPOCH is rebuilt, never re-sent).
+ */
+export function classifyRotate(chain, revokedAt, rotator) {
+    if (keyEpochAfter(chain, revokedAt))
+        return "complete";
+    return rotator ? "pending" : "awaiting-rotation";
+}
+/** Whether a KEY_EPOCH is accepted at a control sequence greater than `seq` (§8.4: the mark clears). */
+export function keyEpochAfter(chain, seq) {
+    return chain.records.some((r) => r.body.type === "KEY_EPOCH" && r.payload.controlSeq > seq);
+}
+/**
+ * A Package phase `(resource, epoch, recipient)` (§9.2): never superseded;
+ * `complete` when the ledger records it; a recipient that is no longer a
+ * reader at the head is skipped.
+ */
+export function classifyPackage(ledgered, readerAtHead) {
+    if (ledgered)
+        return "complete";
+    return readerAtHead ? "pending" : "skipped";
+}
+//# sourceMappingURL=phases.js.map

package/dist/identity/proof.d.ts

@@ -0,0 +1,45 @@
+import { type ControlRecordId, type ResourceId } from "@openlfcp/core";
+import type { FlowOptions } from "./devices.js";
+/**
+ * What a device that may have been revoked shows for a Resource
+ * (IDENTITY-PROFILE-01 §8.6). The device distinguishes, from evidence
+ * only:
+ *
+ * - `access-refused`: the coordinator refuses its reads
+ *   (`NACK(AUTHORIZATION_FAILED)`) and proves nothing: "This device no
+ *   longer has access to this section; it may have been removed from your
+ *   identity". A server without `identity-01`, or a device that never
+ *   read, stays here.
+ * - `revocation-proven`: the Control prefix through the revoking record,
+ *   obtained through the revoked-reader read of W §41 and verified here
+ *   (the record revokes this device, which held `data/read` just before
+ *   it and holds nothing after): "This device was removed from your
+ *   identity".
+ *
+ * In both states the device must not create Data Units for the Resource,
+ * and it is never re-paired under the same Principal (N5). A timeout is
+ * `unreachable`, never a decision.
+ */
+export type RevocationStatus = {
+    readonly kind: "active";
+} | {
+    readonly kind: "access-refused";
+    readonly code: string;
+} | {
+    readonly kind: "revocation-proven";
+    /** The revoking DEVICE_REVOKE. */
+    readonly record: ControlRecordId;
+    readonly reason: bigint;
+    /** The verified prefix, through the revoking record; empty when recalled. */
+    readonly prefix: readonly Uint8Array[];
+    /** The proof was established earlier and is kept (§8.6, N5): a revocation is permanent. */
+    readonly recalled?: true;
+} | {
+    readonly kind: "unreachable";
+    readonly reason: string;
+};
+export declare function revocationStatus(o: FlowOptions & {
+    readonly resource: ResourceId;
+    readonly url: string;
+}): Promise<RevocationStatus>;
+//# sourceMappingURL=proof.d.ts.map

package/dist/identity/proof.js

@@ -0,0 +1,71 @@
+import { bytesEqual, controlRecordId, fromHex, toHex, } from "@openlfcp/core";
+import { ABILITY, hasAbility, revokedReaderPrefix, validateControlChain } from "@openlfcp/wire";
+import { setWriteBarrier, writeBarrier } from "../storage.js";
+import { ChannelPool, IdentityRefused, IdentityUnavailable } from "./network.js";
+export async function revocationStatus(o) {
+    const status = await observe(o);
+    const known = await writeBarrier(o.storage, o.resource);
+    // A proven revocation is permanent (N5): no later observation lifts or
+    // downgrades it, whatever an older prefix or a refusal shows (§8.6).
+    if (known?.state === "revocation-proven" && status.kind !== "revocation-proven")
+        return {
+            kind: "revocation-proven",
+            record: controlRecordId(fromHex(known.record ?? "")),
+            reason: BigInt(known.reason ?? "0"),
+            prefix: [],
+            recalled: true,
+        };
+    // §8.6: in both states the device creates no Data Unit for the Resource; the
+    // barrier is durable, so a restart on an old chain cannot write either.
+    if (status.kind === "access-refused")
+        await setWriteBarrier(o.storage, o.resource, { state: "access-refused", reason: status.code });
+    else if (status.kind === "revocation-proven")
+        await setWriteBarrier(o.storage, o.resource, {
+            state: "revocation-proven",
+            record: toHex(status.record),
+            reason: String(status.reason),
+        });
+    // Evidence of activity lifts only an access refusal.
+    else if (status.kind === "active" && known !== undefined)
+        await setWriteBarrier(o.storage, o.resource, null);
+    return status;
+}
+async function observe(o) {
+    const me = o.installation.signer;
+    const pool = new ChannelPool(o.network);
+    try {
+        const channel = await pool.get(me, o.url);
+        const opened = await channel.open(o.resource);
+        if (opened.kind === "nack")
+            return { kind: "access-refused", code: opened.code };
+        // The whole readable chain, never merged into a longer local one: a prefix proves only itself.
+        const records = await channel.control(o.resource, 0n);
+        const chain = validateControlChain([...records]);
+        if (chain.kind !== "linear" || !bytesEqual(chain.state.resourceId, o.resource))
+            return { kind: "access-refused", code: "INVALID_CONTROL_CHAIN" };
+        const p = me.descriptor.principalId;
+        if (hasAbility(chain.state, p, ABILITY.DATA_READ))
+            return { kind: "active" };
+        const prefix = revokedReaderPrefix(chain, p);
+        // The prefix ends at the revoking record (W §41); anything else proves nothing.
+        if (prefix === undefined || prefix.index !== chain.records.length - 1)
+            return { kind: "access-refused", code: "AUTHORIZATION_FAILED" };
+        return {
+            kind: "revocation-proven",
+            record: prefix.recordId,
+            reason: prefix.reason,
+            prefix: Object.freeze([...records]),
+        };
+    }
+    catch (e) {
+        if (e instanceof IdentityRefused)
+            return { kind: "access-refused", code: e.code };
+        if (e instanceof IdentityUnavailable)
+            return { kind: "unreachable", reason: e.message };
+        throw e;
+    }
+    finally {
+        pool.closeAll();
+    }
+}
+//# sourceMappingURL=proof.js.map

package/dist/identity/reconcile.d.ts

@@ -0,0 +1,73 @@
+import { type PrincipalId, type ResourceId } from "@openlfcp/core";
+import { type CertificateChain, type Signer } from "@openlfcp/wire";
+import { type DocumentWrite, type KeyDelivery } from "./context.js";
+import { type LinearChain, type PhaseState } from "./phases.js";
+import { type IdentityFlowOptions } from "./resource.js";
+import { type RotationOutcome } from "./rotation.js";
+/**
+ * Reconciliation (IDENTITY-PROFILE-01 §7.1): carries the Identity
+ * Resource's device records into every roster Resource and keys every
+ * device of the root, idempotently. Targets are `{I} ∪ roster`; the input
+ * is `I`'s Control state, never the document. Revocations first, then
+ * registrations, then keys (by the ledger, unconditionally), then display
+ * data. Suspended while `I` or the target is forked (§9.7).
+ */
+/** One record reconciliation proposes on a target. */
+export type ReconcileStep = {
+    readonly kind: "revoke";
+    readonly root: PrincipalId;
+    readonly device: PrincipalId;
+    /** Reason 3 is propagated as 0; the approval travels nowhere. */
+    readonly reason: bigint;
+} | {
+    readonly kind: "register";
+    readonly root: PrincipalId;
+    readonly device: PrincipalId;
+    /** `I`'s chain for the device. */
+    readonly chain: CertificateChain;
+};
+/**
+ * §7.1 steps 1 and 2 for one target, in their normative order. For the
+ * target `I` itself both steps are vacuous. Registrations are planned on
+ * the target's state as the revocations leave it (a device whose issuer
+ * `I` revoked is never registered before the cascade reaches the target).
+ */
+export declare function planReconciliation(identity: LinearChain, target: LinearChain): readonly ReconcileStep[];
+/** The record of a step on the target's head, signed by the reconciler. */
+export declare function reconcileRecord(target: LinearChain, step: ReconcileStep, signer: Signer): Uint8Array;
+export interface TargetReconciliation {
+    readonly resource: ResourceId;
+    readonly status: "done" | "unsupported" | "unreachable" | "conflict" | "not-authorized";
+    /** Each proposed step and its §9.2 phase state. */
+    readonly steps: readonly {
+        readonly step: ReconcileStep;
+        readonly state: PhaseState | "refused";
+    }[];
+    readonly keys?: KeyDelivery;
+    readonly rotation?: RotationOutcome;
+}
+/**
+ * §7.1: reconciles `{I} ∪ roster` from this managing installation (the
+ * root, or an active personal device with `12`). Proposals the target
+ * refuses are reported, not repeated as such; a second run proposes
+ * nothing. When the target holds an exposing revocation since its epoch
+ * opened and this installation is the rotator, it rotates (§8.4).
+ */
+export declare function reconcileDevices(o: IdentityFlowOptions & {
+    /** Only these targets (default: `I` and the whole roster). */
+    readonly only?: readonly ResourceId[];
+    /** Apply the rotation policy of §8.4 to each target (default true). */
+    readonly rotate?: boolean;
+}): Promise<{
+    readonly operation: string;
+    readonly targets: readonly TargetReconciliation[];
+    /**
+     * Step 4's unit of display data in `I`: not needed (`none`), written,
+     * found written by another manager when built (`complete`, nothing sent),
+     * or refused with `code`. A refused unit leaves this operation open.
+     * Reconciliation has no resume: a later call is a new operation that
+     * proposes the entries still missing then, and does not close this one.
+     */
+    readonly document: DocumentWrite;
+}>;
+//# sourceMappingURL=reconcile.d.ts.map

package/dist/identity/reconcile.js

@@ -0,0 +1,273 @@
+import { bytesEqual, fromBase64url, fromHex, principalId, resourceId, secureRandom, toHex, } from "@openlfcp/core";
+import { activeDevice, actsFor, DEVICE_KIND, deviceFingerprint, revocationOf, signControlRecord, } from "@openlfcp/wire";
+import { deliverKeys, fetchDeks, genesisOwner, IdentityConflict, loadIdentityDocument, readersAt, runControlPhase, runUnitPhase, sealIdentityUnit, syncChain, } from "./context.js";
+import { mayManageDevices } from "./devices.js";
+import { principalRefOf, resourceRef } from "./document.js";
+import { newOperationId, OperationJournal, PackageLedger } from "./journal.js";
+import { ChannelPool, IDENTITY_EXTENSION, IdentityRefused, IdentityUnavailable, } from "./network.js";
+import { classifyRegister, classifyRevoke } from "./phases.js";
+import { identityTarget } from "./resource.js";
+import { rotateIfExposed } from "./revocation.js";
+import { resumeRotations } from "./rotation.js";
+/**
+ * §7.1 steps 1 and 2 for one target, in their normative order. For the
+ * target `I` itself both steps are vacuous. Registrations are planned on
+ * the target's state as the revocations leave it (a device whose issuer
+ * `I` revoked is never registered before the cascade reaches the target).
+ */
+export function planReconciliation(identity, target) {
+    if (bytesEqual(identity.state.resourceId, target.state.resourceId))
+        return [];
+    const R = genesisOwner(identity);
+    const I = identity.state;
+    const X = target.state;
+    const steps = [];
+    // Step 1: every revoked pair of I not revoked in X, in I's chain order.
+    const revokedInX = (d) => revocationOf(X, R, d) !== undefined;
+    const revokedNow = new Set();
+    for (const r of identity.records) {
+        if (r.body.type !== "DEVICE_REVOKE" || !bytesEqual(r.body.root, R))
+            continue;
+        const d = r.body.device;
+        if (revokedInX(d) || revokedNow.has(toHex(d)))
+            continue;
+        revokedNow.add(toHex(d));
+        steps.push({
+            kind: "revoke",
+            root: R,
+            device: d,
+            reason: r.body.reason === 3n ? 0n : r.body.reason,
+        });
+    }
+    const revokedAfter = (d) => revokedInX(d) || revokedNow.has(toHex(d));
+    // Step 2: registrations, in I's binding order.
+    for (const [hex, d] of I.devices) {
+        if (!bytesEqual(d.root, R) || d.chain === null || d.leafId === null)
+            continue;
+        const D = principalId(fromHex(hex));
+        if (revokedAfter(D) || d.chain.issuers.some((e) => revokedAfter(e)))
+            continue;
+        const x = X.devices.get(hex);
+        if (d.kind === DEVICE_KIND.PERSONAL) {
+            if (activeDevice(I, D) === undefined)
+                continue;
+            if (x?.registered && x.leafId !== null && bytesEqual(x.leafId, d.leafId))
+                continue;
+            steps.push({ kind: "register", root: R, device: D, chain: d.chain });
+        }
+        else if (d.kind === DEVICE_KIND.SERVICE) {
+            if (revocationOf(I, R, D) !== undefined)
+                continue;
+            if (!d.scope.some((s) => bytesEqual(s, X.resourceId)))
+                continue;
+            // Absent from X, or bound there with another leaf and suspended by the cascade:
+            // I's chain re-certifies it (§7.1 step 2, third item; F09). Kind, mask and
+            // scope are immutable (N8): a binding with others is left alone.
+            if (x !== undefined) {
+                if (x.leafId !== null && bytesEqual(x.leafId, d.leafId))
+                    continue;
+                if (activeDevice(X, D) !== undefined || !sameBinding(x, d))
+                    continue;
+            }
+            steps.push({ kind: "register", root: R, device: D, chain: d.chain });
+        }
+    }
+    return Object.freeze(steps);
+}
+const sameSet = (a, b) => a.length === b.length && a.every((v) => b.includes(v));
+/** N8: the same kind, mask and scope. */
+const sameBinding = (a, b) => a.kind === b.kind &&
+    sameSet(a.mask.map(String), b.mask.map(String)) &&
+    sameSet(a.scope.map(toHex), b.scope.map(toHex));
+/** The record of a step on the target's head, signed by the reconciler. */
+export function reconcileRecord(target, step, signer) {
+    const header = {
+        resourceId: target.state.resourceId,
+        controlSeq: target.state.seq + 1n,
+        prevControlId: target.state.head,
+    };
+    return step.kind === "revoke"
+        ? signControlRecord(header, { type: "DEVICE_REVOKE", root: step.root, device: step.device, reason: step.reason }, signer).bytes
+        : signControlRecord(header, { type: "DEVICE_GRANT", root: step.root, chain: step.chain }, signer).bytes;
+}
+/**
+ * §7.1: reconciles `{I} ∪ roster` from this managing installation (the
+ * root, or an active personal device with `12`). Proposals the target
+ * refuses are reported, not repeated as such; a second run proposes
+ * nothing. When the target holds an exposing revocation since its epoch
+ * opened and this installation is the rotator, it rotates (§8.4).
+ */
+export async function reconcileDevices(o) {
+    const target = await identityTarget(o);
+    const me = o.installation.signer;
+    const journal = new OperationJournal(o.storage);
+    const ledger = new PackageLedger(o.storage);
+    const operation = newOperationId("reconcile", secureRandom(8));
+    await journal.begin({
+        id: operation,
+        kind: "reconcile",
+        createdAt: o.now(),
+        intent: { identity: toHex(target.resource) },
+    });
+    const pool = new ChannelPool(o.network);
+    const out = [];
+    let document = { state: "none" };
+    let open = false;
+    try {
+        // A rotation an earlier run committed but did not adopt is finished first (§9.1).
+        await resumeRotations({ ...o, pool });
+        const channel = await pool.get(me, target.url);
+        const I = await syncChain(o.storage, channel, target.resource);
+        const R = genesisOwner(I);
+        if (!mayManageDevices(I.state, me.descriptor.principalId, R))
+            return {
+                operation,
+                targets: [{ resource: target.resource, status: "not-authorized", steps: [] }],
+                document,
+            };
+        const doc = o.document(target.resource, R);
+        const deksI = await fetchDeks(o.storage, o.secrets, channel, I, o.installation);
+        await loadIdentityDocument({ channel, chain: I, deks: deksI, doc });
+        const hints = (resource) => {
+            const ref = resourceRef(resource);
+            const m = new Map();
+            for (const [key, e] of doc.devices()) {
+                const epochs = e.missing_keys?.[ref];
+                const d = key.startsWith("p:") ? toHex(fromBase64url(key.slice(2))) : undefined;
+                if (epochs !== undefined && d !== undefined)
+                    m.set(d, new Set(epochs.map(String)));
+            }
+            return m;
+        };
+        const targets = [
+            { resource: target.resource, url: target.url },
+            ...[...doc.roster()]
+                .filter(([, e]) => e.archived !== true)
+                .map(([ref, e]) => ({ resource: resourceId(fromBase64url(ref)), url: e.coordinator }))
+                .filter((t) => !bytesEqual(t.resource, target.resource)),
+        ].filter((t) => o.only === undefined || o.only.some((r) => bytesEqual(r, t.resource)));
+        for (const t of targets) {
+            try {
+                const c = await pool.get(me, t.url);
+                if (!c.extensions.includes(IDENTITY_EXTENSION)) {
+                    out.push({ resource: t.resource, status: "unsupported", steps: [] });
+                    continue;
+                }
+                out.push(await reconcileTarget(o, c, journal, ledger, operation, I, t.resource, hints(t.resource)));
+            }
+            catch (e) {
+                if (e instanceof IdentityUnavailable || e instanceof IdentityRefused)
+                    out.push({ resource: t.resource, status: "unreachable", steps: [] });
+                else if (e instanceof IdentityConflict)
+                    out.push({ resource: t.resource, status: "conflict", steps: [] });
+                else
+                    throw e;
+            }
+        }
+        // Step 4: display data for devices in I's chain without a valid entry (labels default to the fingerprint).
+        if (displayIntents(I, doc, R).length > 0 && doc.initialized()) {
+            // Built on the current state of I: a rotation of I by this run, or by
+            // anyone, makes an earlier unit stale (W §19.1), and it is written again.
+            document = await runUnitPhase(channel, journal, operation, {
+                id: "display",
+                resource: target.resource,
+                rebuildOn: ["STALE_DATA_EPOCH"],
+                build: async () => {
+                    const now = await syncChain(o.storage, channel, target.resource);
+                    const deks = await fetchDeks(o.storage, o.secrets, channel, now, o.installation);
+                    const fresh = o.document(target.resource, R);
+                    const loaded = await loadIdentityDocument({ channel, chain: now, deks, doc: fresh });
+                    // Another manager may have written the entries since the first read (§7.1).
+                    const intents = displayIntents(now, fresh, R);
+                    if (intents.length === 0)
+                        return null;
+                    return sealIdentityUnit({
+                        storage: o.storage,
+                        chain: now,
+                        deks,
+                        signer: me,
+                        doc: fresh,
+                        latest: loaded.latest,
+                        intents,
+                    });
+                },
+            });
+        }
+        open =
+            document.state === "refused" ||
+                out.some((t) => t.status === "unreachable" ||
+                    t.status === "conflict" ||
+                    t.rotation?.status === "unreachable" ||
+                    t.rotation?.status === "awaiting-key-holder");
+        await journal.setStatus(operation, open ? "open" : "done");
+    }
+    catch (e) {
+        if (e instanceof IdentityConflict)
+            out.push({ resource: target.resource, status: "conflict", steps: [] });
+        else if (e instanceof IdentityUnavailable)
+            out.push({ resource: target.resource, status: "unreachable", steps: [] });
+        else
+            throw e;
+    }
+    finally {
+        pool.closeAll();
+    }
+    return { operation, targets: Object.freeze(out), document };
+}
+/** §7.1 step 4: a device entry for each device of R in I's chain without one. */
+function displayIntents(I, doc, R) {
+    const intents = [];
+    for (const [hex, d] of I.state.devices) {
+        if (!bytesEqual(d.root, R) || d.chain === null || d.kind === DEVICE_KIND.PAIRING)
+            continue;
+        const key = principalRefOf(principalId(fromHex(hex)));
+        if (doc.devices().has(key))
+            continue;
+        intents.push({
+            intent: "device.put",
+            key,
+            entry: {
+                label: deviceFingerprint(principalId(fromHex(hex))),
+                kind: d.kind === DEVICE_KIND.SERVICE ? 1 : 0,
+            },
+        });
+    }
+    return intents;
+}
+async function reconcileTarget(o, channel, journal, ledger, operation, I, X, resend) {
+    const me = o.installation.signer;
+    const R = genesisOwner(I);
+    let chain = await syncChain(o.storage, channel, X);
+    const steps = [];
+    const manages = mayManageDevices(chain.state, me.descriptor.principalId, R);
+    if (manages)
+        for (const step of planReconciliation(I, chain)) {
+            const id = `${step.kind}:${toHex(X)}:${toHex(step.device)}`;
+            const outcome = await runControlPhase(o.storage, channel, journal, operation, {
+                id,
+                kind: step.kind,
+                resource: X,
+                classify: (c, isOwn) => step.kind === "revoke"
+                    ? classifyRevoke(c.state, step.root, step.device)
+                    : classifyRegister(c, { root: step.root, chain: step.chain, isOwnRecord: isOwn }),
+                build: (c) => reconcileRecord(c, step, me),
+            });
+            steps.push({ step, state: outcome.state });
+            chain = outcome.chain;
+        }
+    // Step 3: every reader of the target whose root is R (pairing devices of I included), by the ledger.
+    const deks = await fetchDeks(o.storage, o.secrets, channel, chain, o.installation);
+    const recipients = readersAt(chain.state).filter((r) => bytesEqual(actsFor(chain.state, r.principalId), R));
+    const keys = await deliverKeys({ channel, ledger, chain, sender: me, recipients, deks, resend });
+    const rotation = o.rotate === false
+        ? undefined
+        : await rotateIfExposed({ ...o, channel, operation, resource: X });
+    return {
+        resource: X,
+        status: manages ? "done" : "not-authorized",
+        steps: Object.freeze(steps),
+        keys,
+        ...(rotation === undefined ? {} : { rotation }),
+    };
+}
+//# sourceMappingURL=reconcile.js.map