@openlfcp/client 0.2.2 → 0.3.1

package/dist/identity/pairing.js

@@ -0,0 +1,624 @@
+import { bytesEqual, fromBase64url, fromHex, hash32, principalId, resourceId, secureRandom, toBase64url, toHex, } from "@openlfcp/core";
+import { InvitationSecret } from "@openlfcp/crypto";
+import { activeDevice, assemblePairingUri, certificateChain, DEVICE_KIND, decodeInviteSecret, decodePrincipalDescriptor, deviceCertificatePayloadDigest, deviceFingerprint, encodePrincipalDescriptor as encodeDescriptor, encodeInviteSecret, InMemorySeenUnits, invitationPrincipal, parseDataUnit, parseDeviceCertificate, receiveDataUnit, signControlRecord, } from "@openlfcp/wire";
+import { deliverKeys, fetchDeks, genesisOwner, IdentityConflict, loadIdentityDocument, runControlPhase, runUnitPhase, sealIdentityUnit, syncChain, } from "./context.js";
+import { checkIssuance, leafPayload, MASK_PRESETS, mayManageDevices, registerDevice, signChain, } from "./devices.js";
+import { identityPlaintextCodec, principalOfRef, principalRefOf, } from "./document.js";
+import { newOperationId, OperationJournal, PackageLedger, pairingSecretRef, phaseOf, } from "./journal.js";
+import { ChannelPool, IdentityUnavailable } from "./network.js";
+import { classifyCancel, classifyConsume, classifyRegister } from "./phases.js";
+import { identityTarget } from "./resource.js";
+import { rotateIfExposed } from "./revocation.js";
+/**
+ * Pairing a new installation, the managing side `A` (IDENTITY-PROFILE-01
+ * §5.3 steps 1, 4–7, 9 and 10): a pairing device `J` registered in the
+ * Identity Resource for one session, the request it carries validated and
+ * checked against the complete future certificate chain, then the two
+ * phases: consume `J` with the approved payload's digest, sign and register
+ * exactly that payload. Every phase is journaled and classified by §9.2, so
+ * a crash or a lost answer resumes without signing anything else; a
+ * pairing session yields at most one approved payload.
+ */
+/** A bearer link (§5.2): its text is revealed on demand and never logged. */
+export class PairingLinkText {
+    #uri;
+    constructor(uri) {
+        this.#uri = uri;
+    }
+    /** The lfcp://pair URI with its #secret= fragment. Show it to the human; never log it. */
+    reveal() {
+        return this.#uri;
+    }
+    toJSON() {
+        return "[redacted]";
+    }
+    toString() {
+        return "[redacted]";
+    }
+    [Symbol.for("nodejs.util.inspect.custom")]() {
+        return "[redacted]";
+    }
+}
+const PAIRING_MASK = [1n, 2n];
+/** Wraps a flow body: transport failures and forks become results, the journal stays. */
+async function guarded(pool, body, unavailable, conflict) {
+    try {
+        return await body();
+    }
+    catch (e) {
+        if (e instanceof IdentityUnavailable)
+            return unavailable(e.message);
+        if (e instanceof IdentityConflict)
+            return conflict();
+        throw e;
+    }
+    finally {
+        pool.closeAll();
+    }
+}
+/**
+ * §5.3 step 1: creates a pairing device `J` (kind 2, mask {1, 2}, scope
+ * [I]), registers it in `I`, seals to it the DEK of every epoch of `I`, and
+ * returns the link. Before anything is committed `A` must hold, verified,
+ * the root's unit 1 and the DEK of every epoch of `I` (otherwise no link),
+ * and the DEVICE_GRANT must fit the root's 32 live devices (W §17.4 rule 8).
+ */
+export async function createPairingSession(o) {
+    const target = await identityTarget(o);
+    const pool = new ChannelPool(o.network);
+    const me = o.installation.signer;
+    return guarded(pool, async () => {
+        const channel = await pool.get(me, target.url);
+        const chain = await syncChain(o.storage, channel, target.resource);
+        const R = genesisOwner(chain);
+        if (!mayManageDevices(chain.state, me.descriptor.principalId, R))
+            return {
+                kind: "not-authorized",
+                reason: "only the root or an active managing device creates a pairing session",
+            };
+        const missing = await missingMaterial(o, channel, chain);
+        if (missing.length > 0)
+            return { kind: "missing-material", missing };
+        // J's keys go to the SecretStore before the journal row names J (§9.8).
+        const secret = InvitationSecret.generate();
+        const J = invitationPrincipal(secret);
+        const leaf = leafPayload(R, J, DEVICE_KIND.PAIRING, PAIRING_MASK, [target.resource]);
+        const feasible = checkIssuance({ chain, issuer: me, leaf });
+        if (!feasible.feasible)
+            return /rule 8/.test(feasible.reason)
+                ? { kind: "limit", reason: feasible.reason }
+                : { kind: "not-authorized", reason: feasible.reason };
+        const bytes = encodeInviteSecret(secret);
+        try {
+            await o.secrets.put(pairingSecretRef(J.principalId), bytes);
+        }
+        finally {
+            bytes.fill(0);
+        }
+        const chainJ = signChain(chain.state, me, leaf);
+        const session = newOperationId("pairing-session", secureRandom(8));
+        await new OperationJournal(o.storage).begin({
+            id: session,
+            kind: "pairing-session",
+            createdAt: o.now(),
+            intent: {
+                identity: toHex(target.resource),
+                url: target.url,
+                endpoints: [...(o.endpoints ?? [target.url])],
+                pairingDevice: toHex(J.principalId),
+                root: toHex(R),
+                certificates: chainJ.certificates.map((c) => toHex(c.signed.bytes)),
+            },
+        });
+        return finishSession(o, pool, session);
+    }, (reason) => ({ kind: "unavailable", reason }), () => ({ kind: "conflict" }));
+}
+/**
+ * §5.3 step 1 after a crash before the link was shown: completes the
+ * registration of `J` and its packages from the journal, then returns the
+ * link again.
+ */
+export async function resumePairingSession(o, session) {
+    const pool = new ChannelPool(o.network);
+    return guarded(pool, () => finishSession(o, pool, session), (reason) => ({ kind: "unavailable", session, reason }), () => ({ kind: "conflict" }));
+}
+async function missingMaterial(o, channel, chain) {
+    const missing = [];
+    const deks = await fetchDeks(o.storage, o.secrets, channel, chain, o.installation);
+    for (const e of chain.state.epochs.values())
+        if (!deks.has(String(e.epoch)))
+            missing.push(`the DEK of epoch ${e.epoch}`);
+    // The carrier of the initial change (§2.2), verified, and retrievable for B.
+    const R = genesisOwner(chain);
+    // Exactly the root's unit at actor sequence 1, whatever else DATA_GET returns.
+    const unit = (await channel.dataUnits(chain.state.resourceId, [{ actor: R, start: 1n, end: 1n }])).find((u) => {
+        const p = parseDataUnit(u).payload;
+        return bytesEqual(p.actor, R) && p.actorSeq === 1n && p.prevDataUnitId === null;
+    });
+    const opened = unit === undefined
+        ? undefined
+        : await receiveDataUnit(chain, unit, {
+            seen: new InMemorySeenUnits(),
+            dek: (epoch) => deks.get(String(epoch)),
+            profile: identityPlaintextCodec,
+        });
+    if (opened?.kind !== "accepted")
+        missing.push("the root's Data Unit with actor sequence 1");
+    return missing;
+}
+async function finishSession(o, pool, session) {
+    const journal = new OperationJournal(o.storage);
+    const op = await journal.load(session);
+    const I = resourceId(fromHex(op.intent.identity));
+    const R = principalId(fromHex(op.intent.root));
+    const J = principalId(fromHex(op.intent.pairingDevice));
+    const chainJ = certificateChain(op.intent.certificates.map((c) => parseDeviceCertificate(fromHex(c))), R);
+    const me = o.installation.signer;
+    const channel = await pool.get(me, op.intent.url);
+    const grant = await runControlPhase(o.storage, channel, journal, session, {
+        id: "grant",
+        kind: "register",
+        resource: I,
+        classify: (chain, isOwn) => classifyRegister(chain, { root: R, chain: chainJ, isOwnRecord: isOwn }),
+        build: (chain) => signControlRecord({ resourceId: I, controlSeq: chain.state.seq + 1n, prevControlId: chain.state.head }, { type: "DEVICE_GRANT", root: R, chain: chainJ }, me).bytes,
+    });
+    if (grant.state === "refused" || grant.state === "superseded") {
+        await journal.setStatus(session, "abandoned");
+        if (grant.state === "refused" && grant.code === "AUTHORIZATION_FAILED")
+            return { kind: "limit", reason: "the coordinator refused the pairing device (W §17.4)" };
+        return { kind: "refused", code: grant.code ?? grant.state };
+    }
+    // Every epoch of I to J (same root, W §25.2), before the link is shown.
+    const deks = await fetchDeks(o.storage, o.secrets, channel, grant.chain, o.installation);
+    const delivery = await deliverKeys({
+        channel,
+        ledger: new PackageLedger(o.storage),
+        chain: grant.chain,
+        sender: me,
+        recipients: [grant.chain.state.principals.get(toHex(J)) ?? chainJ.leaf.payload.device],
+        deks,
+    });
+    if (delivery.skipped.length > 0)
+        throw new IdentityUnavailable(`the packages to the pairing device were not all accepted: ${delivery.skipped.map((s) => s.reason).join("; ")}`);
+    // §5.3 step 1, again right before the link is shown: J must hold every
+    // epoch of I and the root's unit 1 must be retrievable; a resumed session
+    // may meet a newer epoch or a coordinator that lost the unit.
+    const now = await syncChain(o.storage, channel, I);
+    const missing = await missingMaterial(o, channel, now);
+    for (const e of now.state.epochs.values())
+        if (!(await new PackageLedger(o.storage).has(I, e.epoch, J)))
+            missing.push(`the package of epoch ${e.epoch} to the pairing device`);
+    if (missing.length > 0)
+        return { kind: "missing-material", missing };
+    const bytes = await o.secrets.get(pairingSecretRef(J));
+    if (bytes === undefined)
+        throw new Error("the pairing device's secret is not in the SecretStore");
+    let secret;
+    try {
+        secret = decodeInviteSecret(bytes);
+    }
+    finally {
+        bytes.fill(0);
+    }
+    const link = assemblePairingUri({
+        identityResourceId: I,
+        endpoints: op.intent.endpoints,
+        pairingDevice: J,
+        secret,
+    });
+    return { kind: "created", session, pairingDevice: J, link: new PairingLinkText(link) };
+}
+const tupleOf = (key, entry, changes) => JSON.stringify([
+    changes,
+    key,
+    entry.descriptor,
+    entry.pairing,
+    entry.label,
+    entry.kind,
+    entry.scope ?? [],
+    entry.platform ?? null,
+]);
+async function readSession(o, session) {
+    const op = await new OperationJournal(o.storage).load(session);
+    return {
+        op,
+        I: resourceId(fromHex(op.intent.identity)),
+        R: principalId(fromHex(op.intent.root)),
+        J: principalId(fromHex(op.intent.pairingDevice)),
+        url: op.intent.url,
+    };
+}
+async function openIdentity(o, channel, I) {
+    const chain = await syncChain(o.storage, channel, I);
+    const doc = o.document(I, genesisOwner(chain));
+    const load = await loadIdentityDocument({
+        channel,
+        chain,
+        deks: await fetchDeks(o.storage, o.secrets, channel, chain, o.installation),
+        doc,
+    });
+    return { chain, doc, load };
+}
+function presetsFor(chain, o, R, J, device, kind, scope) {
+    const names = kind === 0 ? ["full", "edit", "read"] : ["service"];
+    return names.map((preset) => {
+        const p = MASK_PRESETS[preset];
+        if (kind === 1 && scope.length === 0)
+            return { preset, offered: false, reason: "a service scope must keep at least one Resource" };
+        const f = checkIssuance({
+            chain,
+            issuer: o.installation.signer,
+            leaf: leafPayload(R, device, p.kind, p.mask, kind === 1 ? scope : []),
+            pairing: J,
+        });
+        return f.feasible ? { preset, offered: true } : { preset, offered: false, reason: f.reason };
+    });
+}
+function reviewOf(o, session, chain, doc, R, J, I, key, entry) {
+    // §5.3 step 4: the entry names this session's J, J is an active pairing
+    // device of R, and every change that wrote the entry was signed by J.
+    if (entry.pairing !== principalRefOf(J))
+        return undefined;
+    const j = activeDevice(chain.state, J);
+    if (j === undefined || j.kind !== DEVICE_KIND.PAIRING || !bytesEqual(j.root, R))
+        return undefined;
+    const origins = doc.origins("requests", key);
+    if (origins.length === 0 || origins.some((w) => !bytesEqual(w.signer, J)))
+        return undefined;
+    const requestChanges = Object.freeze(origins.map((w) => w.hash));
+    const device = principalOfRef(key);
+    if (device === undefined)
+        return undefined;
+    let descriptor;
+    try {
+        descriptor = decodePrincipalDescriptor(fromBase64url(entry.descriptor));
+    }
+    catch {
+        return undefined;
+    }
+    if (!bytesEqual(descriptor.principalId, device))
+        return undefined;
+    const requestedScope = (entry.scope ?? [])
+        .map((ref) => resourceId(fromBase64url(ref)))
+        // A service scope never lists the Identity Resource (§5.3 step 4).
+        .filter((r) => !bytesEqual(r, I));
+    return Object.freeze({
+        session,
+        requestKey: key,
+        device,
+        descriptor: entry.descriptor,
+        label: entry.label,
+        ...(entry.platform === undefined ? {} : { platform: entry.platform }),
+        kind: entry.kind,
+        requestedScope: Object.freeze(requestedScope),
+        fingerprint: deviceFingerprint(device),
+        presets: Object.freeze(presetsFor(chain, o, R, J, descriptor, entry.kind, requestedScope)),
+        requestChanges,
+        tuple: tupleOf(key, entry, requestChanges),
+    });
+}
+/** §5.3 step 4: the valid requests of a session, each with the presets whose future chain passes. */
+export async function pairingRequests(o) {
+    const { I, R, J, url } = await readSession(o, o.session);
+    const pool = new ChannelPool(o.network);
+    try {
+        const channel = await pool.get(o.installation.signer, url);
+        const { chain, doc, load } = await openIdentity(o, channel, I);
+        const out = [];
+        for (const [key, entry] of doc.requests()) {
+            const r = reviewOf(o, o.session, chain, doc, R, J, I, key, entry);
+            if (r !== undefined)
+                out.push(r);
+        }
+        return Object.freeze(out);
+    }
+    finally {
+        pool.closeAll();
+    }
+}
+/**
+ * §5.3 steps 4–7 and 10: approves the confirmed request with a preset
+ * (and, for a service device, a scope within the requested one). The
+ * complete certificate payload and its digest are journaled before
+ * phase 1; phase 2 signs exactly that payload.
+ */
+export async function approvePairing(o) {
+    const { I, R, J, url } = await readSession(o, o.review.session);
+    const pool = new ChannelPool(o.network);
+    const me = o.installation.signer;
+    const prepared = await guarded(pool, async () => {
+        const channel = await pool.get(me, url);
+        const { chain, doc, load } = await openIdentity(o, channel, I);
+        const entry = doc.requests().get(o.review.requestKey);
+        const review = entry === undefined
+            ? undefined
+            : reviewOf(o, o.review.session, chain, doc, R, J, I, o.review.requestKey, entry);
+        if (review === undefined || review.tuple !== o.review.tuple)
+            return { kind: "reconfirm", review };
+        const preset = MASK_PRESETS[o.preset];
+        if ((preset.kind === DEVICE_KIND.SERVICE) !== (review.kind === 1))
+            return { kind: "infeasible", reason: "the preset's kind is not the requested kind" };
+        const scope = review.kind === 1
+            ? (o.scope ?? review.requestedScope).filter((r) => !bytesEqual(r, I))
+            : [];
+        if (scope.some((r) => !review.requestedScope.some((q) => bytesEqual(q, r))))
+            return { kind: "infeasible", reason: "the approved scope adds a Resource (§5.3 step 4)" };
+        if (review.kind === 1 && scope.length === 0)
+            return {
+                kind: "infeasible",
+                reason: "a service scope trimmed to nothing is not approvable",
+            };
+        const descriptor = decodePrincipalDescriptor(fromBase64url(review.descriptor));
+        const leaf = leafPayload(R, descriptor, preset.kind, preset.mask, scope);
+        const f = checkIssuance({ chain, issuer: me, leaf, pairing: J });
+        if (!f.feasible)
+            return { kind: "infeasible", reason: f.reason };
+        const operation = newOperationId("pairing-approval", secureRandom(8));
+        await new OperationJournal(o.storage).begin({
+            id: operation,
+            kind: "pairing-approval",
+            createdAt: o.now(),
+            intent: {
+                session: o.review.session,
+                identity: toHex(I),
+                url,
+                root: toHex(R),
+                pairingDevice: toHex(J),
+                requestKey: review.requestKey,
+                requestChanges: [...review.requestChanges],
+                fingerprint: review.fingerprint,
+                label: review.label,
+                ...(review.platform === undefined ? {} : { platform: review.platform }),
+                ...(o.addedAt === undefined ? {} : { addedAt: o.addedAt }),
+                payload: payloadToJson(leaf),
+                digest: toHex(deviceCertificatePayloadDigest(leaf)),
+            },
+        });
+        return operation;
+    }, (reason) => ({ kind: "unavailable", reason }), () => ({ kind: "conflict" }));
+    if (typeof prepared !== "string")
+        return prepared;
+    return resumeApproval(o, prepared);
+}
+const payloadToJson = (p) => ({
+    root: toHex(p.root),
+    descriptor: toBase64url(encodeDescriptor(p.device)),
+    kind: p.kind,
+    mask: p.mask.map(String),
+    scope: p.scope.map(toHex),
+    serial: toHex(p.serial),
+});
+function payloadFromJson(j) {
+    return Object.freeze({
+        root: principalId(fromHex(j.root)),
+        device: decodePrincipalDescriptor(fromBase64url(j.descriptor)),
+        kind: j.kind,
+        mask: Object.freeze(j.mask.map(BigInt)),
+        scope: Object.freeze(j.scope.map((s) => resourceId(fromHex(s)))),
+        serial: fromHex(j.serial),
+    });
+}
+class Infeasible extends Error {
+}
+const next = (chain) => ({
+    resourceId: chain.state.resourceId,
+    controlSeq: chain.state.seq + 1n,
+    prevControlId: chain.state.head,
+});
+/** Phase 1 (§5.3 step 5): `DEVICE_REVOKE {R, J, 3, digest}` on the chain's head. */
+export const consumeRecord = (chain, signer, root, pairing, digest) => signControlRecord(next(chain), { type: "DEVICE_REVOKE", root, device: pairing, reason: 3n, approval: digest }, signer).bytes;
+/** Phase 2 (§5.3 step 6): `DEVICE_GRANT {R, chain_B, 2: J}` on the chain's head. */
+export const approvedGrantRecord = (chain, signer, root, device, pairing) => signControlRecord(next(chain), { type: "DEVICE_GRANT", root, chain: device, pairingDevice: pairing }, signer).bytes;
+/** §5.3 step 9: `DEVICE_REVOKE {R, J, 0}` on the chain's head. */
+export const cancelRecord = (chain, signer, root, pairing) => signControlRecord(next(chain), { type: "DEVICE_REVOKE", root, device: pairing, reason: 0n }, signer).bytes;
+/** Resumes a journaled approval from its next phase (§9.1: "If A crashes after step 5 …"). */
+export async function resumeApproval(o, operation) {
+    const journal = new OperationJournal(o.storage);
+    const pool = new ChannelPool(o.network);
+    const me = o.installation.signer;
+    return guarded(pool, async () => {
+        let op = await journal.load(operation);
+        if (op.status === "superseded")
+            return { kind: "superseded", operation };
+        const I = resourceId(fromHex(op.intent.identity));
+        const R = principalId(fromHex(op.intent.root));
+        const J = principalId(fromHex(op.intent.pairingDevice));
+        const leaf = payloadFromJson(op.intent.payload);
+        const digest = hash32(fromHex(op.intent.digest));
+        if (!bytesEqual(deviceCertificatePayloadDigest(leaf), digest))
+            throw new Error("the journaled payload does not match its digest");
+        const channel = await pool.get(me, op.intent.url);
+        // Phase 1: consume J with the digest (§5.3 step 5).
+        let consume;
+        try {
+            consume = await runControlPhase(o.storage, channel, journal, operation, {
+                id: "consume",
+                kind: "consume",
+                resource: I,
+                facts: { digest: toHex(digest) },
+                classify: (chain) => classifyConsume(chain.state, R, J, digest),
+                build: (chain) => {
+                    // The proposer re-checks its own authority on the new head (§5.3 step 5).
+                    const f = checkIssuance({ chain, issuer: me, leaf, pairing: J });
+                    if (!f.feasible)
+                        throw new Infeasible(f.reason);
+                    return consumeRecord(chain, me, R, J, digest);
+                },
+            });
+        }
+        catch (e) {
+            if (!(e instanceof Infeasible))
+                throw e;
+            await journal.setStatus(operation, "abandoned");
+            return { kind: "infeasible", reason: e.message };
+        }
+        if (consume.state === "superseded") {
+            await journal.setStatus(operation, "superseded");
+            return { kind: "superseded", operation };
+        }
+        if (consume.state === "refused") {
+            await journal.setStatus(operation, "abandoned");
+            return { kind: "refused", operation, code: consume.code ?? "refused" };
+        }
+        // Phase 2: sign exactly the journaled payload and register (§5.3 step 6).
+        const chainB = signChain(consume.chain.state, me, leaf);
+        const register = await runControlPhase(o.storage, channel, journal, operation, {
+            id: "register",
+            kind: "register",
+            resource: I,
+            classify: (chain, isOwn) => classifyRegister(chain, {
+                root: R,
+                chain: chainB,
+                pairingPhase2: true,
+                isOwnRecord: isOwn,
+            }),
+            build: (chain) => approvedGrantRecord(chain, me, R, chainB, J),
+        });
+        if (register.state === "superseded") {
+            await journal.setStatus(operation, "superseded");
+            return { kind: "superseded", operation };
+        }
+        if (register.state === "refused") {
+            // Rule 8: the approval stays consumed; propose the same chain after a revocation.
+            if (register.code === "AUTHORIZATION_FAILED") {
+                const p = phaseOf(await journal.load(operation), "register");
+                if (p !== undefined)
+                    await journal.putPhase(operation, { ...p, state: "pending" });
+                return { kind: "limit", operation };
+            }
+            await journal.setStatus(operation, "abandoned");
+            return { kind: "refused", operation, code: register.code ?? "refused" };
+        }
+        // Step 6: the device entry, and the request removed, in one change by A.
+        op = await journal.load(operation);
+        const key = op.intent.requestKey;
+        const deviceEntry = {
+            label: op.intent.label,
+            kind: (leaf.kind === DEVICE_KIND.SERVICE ? 1 : 0),
+            ...(op.intent.platform === undefined ? {} : { platform: op.intent.platform }),
+            ...(op.intent.addedAt === undefined ? {} : { added_at: op.intent.addedAt }),
+        };
+        // A unit refused as stale is written again in the current epoch (W §19.1);
+        // another refusal is reported, and a resumed approval writes it again.
+        const document = await runUnitPhase(channel, journal, operation, {
+            id: "document",
+            resource: I,
+            rebuildOn: ["STALE_DATA_EPOCH"],
+            rebuildRefused: true,
+            build: async () => {
+                const { chain, doc, load } = await openIdentity(o, channel, I);
+                return sealIdentityUnit({
+                    storage: o.storage,
+                    chain,
+                    deks: await fetchDeks(o.storage, o.secrets, channel, chain, o.installation),
+                    signer: me,
+                    doc,
+                    latest: load.latest,
+                    intents: [
+                        { intent: "device.put", key, entry: deviceEntry },
+                        ...(doc.requests().has(key) ? [{ intent: "request.delete", key }] : []),
+                    ],
+                });
+            },
+        });
+        // Step 7: every epoch of I to a personal B, each recorded (§9.5).
+        const chain = await syncChain(o.storage, channel, I);
+        if (leaf.kind === DEVICE_KIND.PERSONAL)
+            await deliverKeys({
+                channel,
+                ledger: new PackageLedger(o.storage),
+                chain,
+                sender: me,
+                recipients: [leaf.device],
+                deks: await fetchDeks(o.storage, o.secrets, channel, chain, o.installation),
+            });
+        // Step 9: J, consumed, was a reader of I: the rotation policy of §8.4 applies to I.
+        const rotation = await rotateIfExposed({ ...o, channel, operation, resource: I });
+        // Step 10: register B in the roster (or the approved scope).
+        const { doc } = await openIdentity(o, channel, I);
+        const targets = [...doc.roster()]
+            .filter(([, e]) => e.archived !== true)
+            .map(([ref, e]) => ({ resource: resourceId(fromBase64url(ref)), url: e.coordinator }))
+            .filter((t) => !bytesEqual(t.resource, I) &&
+            (leaf.kind === DEVICE_KIND.PERSONAL ||
+                leaf.scope.some((s) => bytesEqual(s, t.resource))));
+        const registered = await registerDevice({ ...o, chain: chainB, targets });
+        await journal.updateIntent(operation, { registration: registered.operation });
+        // The session is consumed either way; the approval stays open until its document is written.
+        await journal.setStatus(op.intent.session, "done");
+        const approved = {
+            operation,
+            device: principalId(leaf.device.principalId),
+            chain: chainB,
+            registrations: registered.results,
+            rotation,
+        };
+        if (document.state === "refused")
+            return { kind: "document-incomplete", ...approved, code: document.code ?? "refused" };
+        await journal.setStatus(operation, "done");
+        return { kind: "approved", ...approved };
+    }, (reason) => ({ kind: "unavailable", operation, reason }), () => ({ kind: "conflict" }));
+}
+/**
+ * §5.3 step 9 (rejection, timeout, cancel): `DEVICE_REVOKE {R, J, 0}`.
+ * With `reject`, the request entry is deleted first (step 4: a request the
+ * human does not confirm is rejected).
+ */
+export async function cancelPairing(o) {
+    const { I, R, J, url } = await readSession(o, o.session);
+    const journal = new OperationJournal(o.storage);
+    const pool = new ChannelPool(o.network);
+    const me = o.installation.signer;
+    return guarded(pool, async () => {
+        const channel = await pool.get(me, url);
+        let rejected;
+        if (o.reject !== undefined) {
+            const key = o.reject;
+            rejected = await runUnitPhase(channel, journal, o.session, {
+                id: `reject:${key}`,
+                resource: I,
+                rebuildOn: ["STALE_DATA_EPOCH"],
+                rebuildRefused: true,
+                build: async () => {
+                    const { chain, doc, load } = await openIdentity(o, channel, I);
+                    return sealIdentityUnit({
+                        storage: o.storage,
+                        chain,
+                        deks: await fetchDeks(o.storage, o.secrets, channel, chain, o.installation),
+                        signer: me,
+                        doc,
+                        latest: load.latest,
+                        intents: [{ intent: "request.delete", key }],
+                    });
+                },
+            });
+        }
+        const cancel = await runControlPhase(o.storage, channel, journal, o.session, {
+            id: "cancel",
+            kind: "cancel",
+            resource: I,
+            classify: (chain) => classifyCancel(chain.state, R, J),
+            build: (chain) => cancelRecord(chain, me, R, J),
+        });
+        if (cancel.state === "superseded")
+            return { kind: "consumed" };
+        if (cancel.state === "refused")
+            return { kind: "refused", code: cancel.code ?? "refused" };
+        await o.secrets.delete(pairingSecretRef(J));
+        // A cancelled J was a reader of I: the rotation policy applies (§5.3 step 9, §8.4).
+        const rotation = await rotateIfExposed({ ...o, channel, operation: o.session, resource: I });
+        if (rejected?.state === "refused")
+            return { kind: "document-incomplete", rotation, code: rejected.code ?? "refused" };
+        await journal.setStatus(o.session, "abandoned");
+        return { kind: "cancelled", rotation };
+    }, (reason) => ({ kind: "unavailable", reason }), () => ({ kind: "conflict" }));
+}
+/** Open pairing sessions of this installation, oldest first. */
+export async function openPairingSessions(o) {
+    return (await new OperationJournal(o.storage).list({ kind: "pairing-session", status: "open" })).map((op) => ({
+        session: op.id,
+        identity: resourceId(fromHex(op.intent.identity)),
+        pairingDevice: principalId(fromHex(op.intent.pairingDevice)),
+    }));
+}
+//# sourceMappingURL=pairing.js.map