@openlfcp/client 0.3.0 → 0.3.1

package/dist/identity/accept.js

@@ -1,13 +1,13 @@
 import { bytesEqual, dataEpoch, fromHex, generateResourceId, principalId, resourceId, secureRandom, toHex, } from "@openlfcp/core";
 import { dekCommitment, generateResourceDEK } from "@openlfcp/crypto";
 import { ABILITY, activeDevice, DEVICE_ABILITY, DEVICE_KIND, hasAbility, invitationPrincipal, parseInviteUri, signControlRecord, validateControlChain, verifyInvitationSecret, } from "@openlfcp/wire";
-import { deliverKeys, fetchDeks, genesisOwner, IdentityConflict, loadIdentityDocument, runControlPhase, runUnitPhase, sealIdentityUnit, storeDek, syncChain, } from "./context.js";
+import { deliverKeys, fetchDeks, genesisOwner, IdentityConflict, runControlPhase, storeDek, syncChain, } from "./context.js";
 import { registerDevice } from "./devices.js";
-import { resourceRef } from "./document.js";
 import { newOperationId, OperationJournal, PackageLedger, phaseOf, } from "./journal.js";
 import { ChannelPool, IdentityRefused, IdentityUnavailable } from "./network.js";
 import { classifyRegister } from "./phases.js";
 import { identityTarget } from "./resource.js";
+import { writeRosterEntry } from "./roster.js";
 /**
  * Invitations accepted by a device and Resources created from a device
  * (IDENTITY-PROFILE-01 §7.2, §7.3). Inviting is unchanged; a device that
@@ -77,36 +77,8 @@ async function keyAndList(o, pool, journal, operation, I, iUrl, X, url, entry) {
             others.push(...r.results);
         }
     // §7.2 step 4, §7.3: the roster entry, so the human's other installations reach X.
-    const iChannel = await pool.get(me, iUrl);
-    const openI = async () => {
-        const chainI = await syncChain(o.storage, iChannel, I.state.resourceId);
-        const doc = o.document(I.state.resourceId, genesisOwner(chainI));
-        const deksI = await fetchDeks(o.storage, o.secrets, iChannel, chainI, o.installation);
-        const load = await loadIdentityDocument({ channel: iChannel, chain: chainI, deks: deksI, doc });
-        return { chainI, doc, deksI, load };
-    };
-    let roster = (await openI()).doc.roster().has(resourceRef(X));
-    if (!roster) {
-        const r = await runUnitPhase(iChannel, journal, operation, {
-            id: "roster",
-            resource: I.state.resourceId,
-            // A unit refused after a rotation of I is written again in the new epoch (W §19.1).
-            rebuildOn: ["STALE_DATA_EPOCH"],
-            build: async () => {
-                const { chainI, doc, deksI, load } = await openI();
-                return sealIdentityUnit({
-                    storage: o.storage,
-                    chain: chainI,
-                    deks: deksI,
-                    signer: me,
-                    doc,
-                    latest: load.latest,
-                    intents: [{ intent: "roster.put", key: resourceRef(X), entry }],
-                });
-            },
-        });
-        roster = r.state === "committed-own";
-    }
+    const written = await writeRosterEntry(o, await pool.get(me, iUrl), journal, operation, I.state.resourceId, X, entry);
+    const roster = written.state !== "refused";
     return { rootKeys, siblings: Object.freeze(others), roster };
 }
 /** §7.2: the claim of an invitation for the root, signed by the Invitation Principal (W §18.1 rule 5). */

package/dist/identity/devices.d.ts

@@ -1,6 +1,6 @@
 import { type PrincipalId, type ResourceId } from "@openlfcp/core";
 import type { SecretStore } from "@openlfcp/storage";
-import { type CertificateChain, type ControlState, type DeviceCertificate, type DeviceCertificatePayload, type DeviceKind, type PrincipalDescriptor, type Signer } from "@openlfcp/wire";
+import { type CertificateChain, type ControlState, type DataProfileCodec, type DeviceCertificate, type DeviceCertificatePayload, type DeviceKind, type PrincipalDescriptor, type Signer } from "@openlfcp/wire";
 import { type IdentityStorage, type Installation, type KeyDelivery } from "./context.js";
 import { type IdentityNetwork } from "./network.js";
 import { type LinearChain } from "./phases.js";
@@ -31,6 +31,12 @@ export interface FlowOptions {
     readonly secrets: SecretStore;
     readonly network: IdentityNetwork;
     readonly now: () => number;
+    /**
+     * The application's Data Profile codecs. A rotation uses the Resource's
+     * codec to judge which units recipients accept as data (W §26.3 rule 7);
+     * without one, only decryption and recorded refusals are checked.
+     */
+    readonly dataProfiles?: readonly DataProfileCodec<unknown>[];
 }
 /**
  * The certificates above a leaf that `issuer` signs for `root` in the

package/dist/identity/index.d.ts

@@ -12,5 +12,6 @@ export { type RevocationStatus, revocationStatus } from "./proof.js";
 export { planReconciliation, type ReconcileStep, reconcileDevices, reconcileRecord, type TargetReconciliation, } from "./reconcile.js";
 export { type CreatedIdentityResource, type CreateIdentityResourceOptions, createIdentityResource, type IdentityDocumentFactory, type IdentityFlowOptions, identityTarget, localIdentityResource, resumeIdentityCreation, setLocalIdentityResource, } from "./resource.js";
 export { previewRevocation, type ResourcePreview, type RevocationPreview, type RevocationResult, type RevokeDeviceResult, revokeDevice, rotateIfExposed, } from "./revocation.js";
-export { type ExposingRevocation, exposingRevocationsSince, type RotationOutcome, type RotationStatus, type RotatorTest, rotateAfter, rotatorTest, verifiedFrontier, } from "./rotation.js";
+export { type AddToRosterOptions, type AddToRosterResult, addToRoster, type RosterWrite, writeRosterEntry, } from "./roster.js";
+export { type ExposingRevocation, exposingRevocationsSince, type FrontierData, type LocalAccepted, type RotationOutcome, type RotationStatus, type RotatorTest, rotateAfter, rotatorTest, verifiedFrontier, } from "./rotation.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/identity/index.js

@@ -12,5 +12,6 @@ export { revocationStatus } from "./proof.js";
 export { planReconciliation, reconcileDevices, reconcileRecord, } from "./reconcile.js";
 export { createIdentityResource, identityTarget, localIdentityResource, resumeIdentityCreation, setLocalIdentityResource, } from "./resource.js";
 export { previewRevocation, revokeDevice, rotateIfExposed, } from "./revocation.js";
+export { addToRoster, writeRosterEntry, } from "./roster.js";
 export { exposingRevocationsSince, rotateAfter, rotatorTest, verifiedFrontier, } from "./rotation.js";
 //# sourceMappingURL=index.js.map

package/dist/identity/journal.d.ts

@@ -21,7 +21,7 @@ import type { PhaseState } from "./phases.js";
  * SecretStore only, under the references below, before the row that names
  * them is written (LFCP-034 ordering).
  */
-export type OperationKind = "create-identity" | "pairing-session" | "pairing-approval" | "pairing-request" | "register-device" | "revoke-device" | "rotate" | "reconcile" | "accept-invitation" | "create-resource";
+export type OperationKind = "create-identity" | "pairing-session" | "pairing-approval" | "pairing-request" | "register-device" | "revoke-device" | "rotate" | "reconcile" | "accept-invitation" | "create-resource" | "add-to-roster";
 /** The state of a whole operation. */
 export type OperationStatus = 
 /** Phases remain; resume it. */

package/dist/identity/roster.d.ts

@@ -0,0 +1,89 @@
+import { type ResourceId } from "@openlfcp/core";
+import { type RosterEntryValue } from "./document.js";
+import { OperationJournal } from "./journal.js";
+import { type IdentityChannel } from "./network.js";
+import { type IdentityFlowOptions } from "./resource.js";
+/**
+ * The roster of the Identity Resource (IDENTITY-PROFILE-01 §2.1): how the
+ * human's other installations learn a Resource (§6). An entry is written as
+ * its own durable phase of an operation (§9.1): a unit refused as stale
+ * after a rotation of `I` is written again in the current epoch (W §19.1),
+ * and an entry already present, by this installation or another writer,
+ * is not written again.
+ */
+export type RosterWrite = 
+/** This installation's unit carrying the entry was accepted. */
+{
+    readonly state: "written";
+}
+/** The roster already held an entry for the Resource. */
+ | {
+    readonly state: "present";
+}
+/** The coordinator refused the unit for another reason; the phase stays open. */
+ | {
+    readonly state: "refused";
+    readonly code: string;
+};
+/** Writes `roster[ref(resource)] = entry` in `I` as the phase `roster` of `operation`. */
+export declare function writeRosterEntry(o: IdentityFlowOptions, channel: IdentityChannel, journal: OperationJournal, operation: string, identity: ResourceId, resource: ResourceId, entry: RosterEntryValue): Promise<RosterWrite>;
+export interface AddToRosterOptions extends IdentityFlowOptions {
+    /** The Resource to list (a Resource of the human: created or joined here). */
+    readonly resource: ResourceId;
+    /** A display name for the roster entry. */
+    readonly name?: string;
+    /**
+     * The entry's fields; by default taken from the Resource's Control Chain:
+     * its Data Profile, route endpoints and coordinator (stored here, or read
+     * from `url`).
+     */
+    readonly entry?: RosterEntryValue;
+    /** The Resource's coordinator, when its chain is not stored here. */
+    readonly url?: string;
+    /** Resume this operation. */
+    readonly operation?: string;
+}
+export type AddToRosterResult = 
+/** This installation wrote the entry. */
+{
+    readonly kind: "added";
+    readonly operation: string;
+    readonly resource: ResourceId;
+}
+/** The roster already lists the Resource (written earlier, or by another device). */
+ | {
+    readonly kind: "present";
+    readonly operation: string;
+    readonly resource: ResourceId;
+}
+/** This installation cannot write `I` (`holds(D, 2)` is false, e.g. a Read device, §7.2). */
+ | {
+    readonly kind: "needs-writer";
+}
+/** The coordinator refused the unit: the operation stays open; resume it with `operation`. */
+ | {
+    readonly kind: "document-incomplete";
+    readonly operation: string;
+    readonly resource: ResourceId;
+    readonly code: string;
+} | {
+    readonly kind: "conflict";
+} | {
+    readonly kind: "unavailable";
+    readonly operation?: string;
+    readonly reason: string;
+};
+/**
+ * Adds a Resource to the roster of the Identity Resource as one durable
+ * operation (IDENTITY-PROFILE-01 §2.1, §6, §9): the entry the human's other
+ * installations read to reach the Resource (pairing step 10, reconciliation
+ * §7.1). For a Resource created or joined after `I` was filled (§5.1), for
+ * example a section created later on any personal device. Idempotent: an
+ * entry already present is not written again; a unit refused as stale
+ * after a rotation of `I` is written again in the current epoch; any other
+ * refusal leaves the operation open. Only a writer of `I` (the root or a
+ * personal device holding data/write there) may add entries (§3 AI4: a
+ * pairing or service device never writes the roster).
+ */
+export declare function addToRoster(o: AddToRosterOptions): Promise<AddToRosterResult>;
+//# sourceMappingURL=roster.d.ts.map

package/dist/identity/roster.js

@@ -0,0 +1,130 @@
+import { fromHex, LfcpError, resourceId, secureRandom, toHex, } from "@openlfcp/core";
+import { ABILITY, hasAbility } from "@openlfcp/wire";
+import { loadControlChain } from "../storage.js";
+import { fetchDeks, genesisOwner, IdentityConflict, loadIdentityDocument, runUnitPhase, sealIdentityUnit, syncChain, } from "./context.js";
+import { resourceRef } from "./document.js";
+import { newOperationId, OperationJournal } from "./journal.js";
+import { ChannelPool, IdentityRefused, IdentityUnavailable, } from "./network.js";
+import { identityTarget } from "./resource.js";
+/** Writes `roster[ref(resource)] = entry` in `I` as the phase `roster` of `operation`. */
+export async function writeRosterEntry(o, channel, journal, operation, identity, resource, entry) {
+    const me = o.installation.signer;
+    const openI = async () => {
+        const chain = await syncChain(o.storage, channel, identity);
+        const doc = o.document(identity, genesisOwner(chain));
+        const deks = await fetchDeks(o.storage, o.secrets, channel, chain, o.installation);
+        const load = await loadIdentityDocument({ channel, chain, deks, doc });
+        return { chain, doc, deks, load };
+    };
+    if ((await openI()).doc.roster().has(resourceRef(resource)))
+        return { state: "present" };
+    const r = await runUnitPhase(channel, journal, operation, {
+        id: "roster",
+        resource: identity,
+        // A unit refused after a rotation of I is written again in the new epoch (W §19.1).
+        rebuildOn: ["STALE_DATA_EPOCH"],
+        // A resumed operation whose unit was refused writes the entry again on the
+        // current document, previous unit and actor sequence: the refused bytes may
+        // name a previous unit this actor has since moved past (W §26.2). Exact
+        // bytes are re-sent only after an unknown outcome (§9.1).
+        rebuildRefused: true,
+        build: async () => {
+            const { chain, doc, deks, load } = await openI();
+            // Another writer may have listed the Resource since the last check (a stale
+            // retry, a resume): its entry stands and the phase is complete (§9.2).
+            if (doc.roster().has(resourceRef(resource)))
+                return null;
+            return sealIdentityUnit({
+                storage: o.storage,
+                chain,
+                deks,
+                signer: me,
+                doc,
+                latest: load.latest,
+                intents: [{ intent: "roster.put", key: resourceRef(resource), entry }],
+            });
+        },
+    });
+    if (r.state === "committed-own")
+        return { state: "written" };
+    if (r.state === "complete")
+        return { state: "present" };
+    return { state: "refused", code: r.code ?? "refused" };
+}
+/**
+ * Adds a Resource to the roster of the Identity Resource as one durable
+ * operation (IDENTITY-PROFILE-01 §2.1, §6, §9): the entry the human's other
+ * installations read to reach the Resource (pairing step 10, reconciliation
+ * §7.1). For a Resource created or joined after `I` was filled (§5.1), for
+ * example a section created later on any personal device. Idempotent: an
+ * entry already present is not written again; a unit refused as stale
+ * after a rotation of `I` is written again in the current epoch; any other
+ * refusal leaves the operation open. Only a writer of `I` (the root or a
+ * personal device holding data/write there) may add entries (§3 AI4: a
+ * pairing or service device never writes the roster).
+ */
+export async function addToRoster(o) {
+    const target = await identityTarget(o);
+    const me = o.installation.signer;
+    const journal = new OperationJournal(o.storage);
+    const pool = new ChannelPool(o.network);
+    let operation = o.operation;
+    try {
+        const channel = await pool.get(me, target.url);
+        const I = await syncChain(o.storage, channel, target.resource);
+        if (!hasAbility(I.state, me.descriptor.principalId, ABILITY.DATA_WRITE))
+            return { kind: "needs-writer" };
+        if (operation === undefined || (await journal.get(operation)) === undefined) {
+            const entry = o.entry ?? (await entryOf(o, pool, o.resource));
+            operation = operation ?? newOperationId("add-to-roster", secureRandom(8));
+            await journal.begin({
+                id: operation,
+                kind: "add-to-roster",
+                createdAt: o.now(),
+                intent: {
+                    identity: toHex(target.resource),
+                    resource: toHex(o.resource),
+                    entry: { ...entry, ...(o.name === undefined ? {} : { name: o.name }) },
+                },
+            });
+        }
+        const op = await journal.load(operation);
+        const resource = resourceId(fromHex(op.intent.resource));
+        const written = await writeRosterEntry(o, channel, journal, op.id, target.resource, resource, op.intent.entry);
+        if (written.state === "refused")
+            return { kind: "document-incomplete", operation: op.id, resource, code: written.code };
+        await journal.setStatus(op.id, "done");
+        return { kind: written.state === "written" ? "added" : "present", operation: op.id, resource };
+    }
+    catch (e) {
+        if (e instanceof IdentityUnavailable || e instanceof IdentityRefused)
+            return {
+                kind: "unavailable",
+                ...(operation === undefined ? {} : { operation }),
+                reason: e.message,
+            };
+        if (e instanceof IdentityConflict)
+            return { kind: "conflict" };
+        throw e;
+    }
+    finally {
+        pool.closeAll();
+    }
+}
+/** The roster entry of a Resource from its Control Chain (W §15, §20): profile, routes, coordinator. */
+async function entryOf(o, pool, resource) {
+    const stored = await loadControlChain(o.storage, resource);
+    let chain;
+    if (stored?.kind === "linear")
+        chain = stored;
+    else if (o.url !== undefined)
+        chain = await syncChain(o.storage, await pool.get(o.installation.signer, o.url), resource);
+    else
+        throw new LfcpError("MISSING_DEPENDENCY", "the Resource's chain is not stored here: give its entry or its coordinator URL");
+    return {
+        profile: chain.state.dataProfile,
+        endpoints: chain.state.route.endpoints.map((e) => e.url),
+        coordinator: chain.state.route.coordinatorUrl,
+    };
+}
+//# sourceMappingURL=roster.js.map

package/dist/identity/rotation.d.ts

@@ -1,5 +1,6 @@
 import { type ControlRecordId, type DataEpoch, type PrincipalId, type ResourceId } from "@openlfcp/core";
-import { type ControlState, type HaveVector, type PrincipalDescriptor } from "@openlfcp/wire";
+import { type ResourceDEK } from "@openlfcp/crypto";
+import { type ControlState, type DataProfileCodec, type HaveVector, type PrincipalDescriptor } from "@openlfcp/wire";
 import { type KeyDelivery } from "./context.js";
 import type { FlowOptions } from "./devices.js";
 import { type ChannelPool, type IdentityChannel } from "./network.js";
@@ -40,15 +41,44 @@ export declare function exposingRevocationsSince(chain: LinearChain): readonly E
  * §8.3: the final frontier of the closing epoch from this installation's
  * locally verified accepted set, after a Data synchronisation: a server's
  * Have Vector is a fetch hint; a sequence that cannot be fetched and
- * verified, or that fails authorization, stays outside.
+ * verified, or that fails authorization, stays outside. With `data`, a unit
+ * counts only when recipients accept it as data (W §26.3 rules 6 and 7: it
+ * decrypts under the epoch's DEK and the Data Profile accepts it), so a unit
+ * no recipient can merge never pushes an honest later unit of its actor
+ * beyond the cutoff; rotateAfter always passes it. Without `data` only
+ * signature, authorization and the actor chain are checked (0.3.0).
  */
-export declare function verifiedFrontier(channel: IdentityChannel, chain: LinearChain, local?: LocalAccepted): Promise<HaveVector>;
+export declare function verifiedFrontier(channel: IdentityChannel, chain: LinearChain, local?: LocalAccepted, data?: FrontierData): Promise<HaveVector>;
 /** This installation's stored units of a Resource and its verified Snapshots' coverage. */
 export interface LocalAccepted {
     /** Every signature-valid unit the storage holds for the Resource (exact bytes). */
     readonly units: readonly Uint8Array[];
     /** The sequences verified Snapshots cover (W §29.3). */
     readonly snapshot: HaveVector;
+    /**
+     * Unit IDs (hex) whose bytes this installation proved bad as data: a failed
+     * AEAD or a Data Profile decode refusal. A missing or mismatching DEK is
+     * not such a proof: those units are verified again here.
+     */
+    readonly refused?: ReadonlySet<string>;
+    /**
+     * Unit IDs (hex) this installation accepted on the wire (its actor chain
+     * links through them), including units its profile later refused to
+     * merge: recipients link through them the same way.
+     */
+    readonly accepted?: ReadonlySet<string>;
+}
+/** What the rotating client needs to judge a unit as data (W §26.3 rules 6 and 7). */
+export interface FrontierData {
+    /** The DEKs held for the Resource's epochs, by epoch number. */
+    readonly deks: ReadonlyMap<string, ResourceDEK>;
+    /**
+     * The Resource's Data Profile codec, when the application gives it: its
+     * `decode` is the profile's acceptance. Without it only decryption is
+     * checked here, and a profile refusal this installation recorded still
+     * counts (LocalAccepted.refused).
+     */
+    readonly profile?: DataProfileCodec<unknown>;
 }
 export type RotationStatus = 
 /** This installation committed the KEY_EPOCH and sealed the new DEK to every reader. */

package/dist/identity/rotation.js

@@ -1,6 +1,6 @@
 import { bytesEqual, controlRecordId, fromHex, resourceId, toHex, } from "@openlfcp/core";
 import { generateResourceDEK, sha256 } from "@openlfcp/crypto";
-import { ABILITY, actsFor, addSequence, checkDataUnit, hasAbility, hasSequence, InMemorySeenUnits, isExposingRevocation, KEY_EPOCH_REASON, parseDataUnit, rotateEpoch, } from "@openlfcp/wire";
+import { ABILITY, actsFor, addSequence, checkDataUnit, hasAbility, hasSequence, InMemorySeenUnits, isExposingRevocation, KEY_EPOCH_REASON, parseDataUnit, receiveDataUnit, rotateEpoch, } from "@openlfcp/wire";
 import { snapshotFrontier } from "../outbound.js";
 import { loadControlChain } from "../storage.js";
 import { deliverKeys, fetchDeks, readersAt, runControlPhase, storeDek, withoutEquivocations, } from "./context.js";
@@ -50,9 +50,14 @@ export function exposingRevocationsSince(chain) {
  * §8.3: the final frontier of the closing epoch from this installation's
  * locally verified accepted set, after a Data synchronisation: a server's
  * Have Vector is a fetch hint; a sequence that cannot be fetched and
- * verified, or that fails authorization, stays outside.
+ * verified, or that fails authorization, stays outside. With `data`, a unit
+ * counts only when recipients accept it as data (W §26.3 rules 6 and 7: it
+ * decrypts under the epoch's DEK and the Data Profile accepts it), so a unit
+ * no recipient can merge never pushes an honest later unit of its actor
+ * beyond the cutoff; rotateAfter always passes it. Without `data` only
+ * signature, authorization and the actor chain are checked (0.3.0).
  */
-export async function verifiedFrontier(channel, chain, local = { units: [], snapshot: [] }) {
+export async function verifiedFrontier(channel, chain, local = { units: [], snapshot: [] }, data) {
     const R = chain.state.resourceId;
     const opened = await channel.open(R);
     const ranges = opened.kind === "nack"
@@ -90,10 +95,20 @@ export async function verifiedFrontier(channel, chain, local = { units: [], snap
         const check = await checkDataUnit(chain, bytes, seen);
         if (check.kind !== "valid")
             continue;
+        const covered = hasSequence(local.snapshot, p.actor, p.actorSeq);
+        // W §26.3 rules 6 and 7: a unit recipients cannot decrypt, or whose plaintext
+        // the Data Profile refuses, is not accepted data. It is not counted and does
+        // not become the actor's latest unit, so the honest unit after it, which names
+        // the actor's last good unit (W §26.2), still links. Units a verified Snapshot
+        // covers are attested by it (W §29.3).
+        if (!covered &&
+            data !== undefined &&
+            !(await acceptedAsData(chain, bytes, toHex(check.unitId), local, data)))
+            continue;
         const actor = toHex(p.actor);
         const last = latest.get(actor);
         let links;
-        if (hasSequence(local.snapshot, p.actor, p.actorSeq))
+        if (covered)
             links = true;
         else {
             // The actor's last accepted position: its latest held unit or the highest
@@ -137,6 +152,33 @@ function coveredTop(vector, actor) {
             best = end;
     return best;
 }
+const opaque = (dataProfile) => ({
+    dataProfile,
+    encode: (v) => v,
+    decode: (v) => v,
+});
+/**
+ * Whether recipients accept the unit as data: its DEK is held and matches
+ * the epoch's commitment, it decrypts, and the profile accepts the plaintext
+ * (receiveDataUnit's own steps, on a fresh accepted set: "held" for a link
+ * not decided here means those steps passed). A unit this client cannot
+ * decrypt cannot be verified and stays outside the frontier (W §19).
+ */
+async function acceptedAsData(chain, bytes, unitId, local, data) {
+    if (local.accepted?.has(unitId) === true)
+        return true;
+    if (local.refused?.has(unitId) === true)
+        return false;
+    const profile = data.profile !== undefined && data.profile.dataProfile === chain.state.dataProfile
+        ? data.profile
+        : opaque(chain.state.dataProfile);
+    const r = await receiveDataUnit(chain, bytes, {
+        seen: new InMemorySeenUnits(),
+        dek: (epoch) => data.deks.get(String(epoch)),
+        profile,
+    });
+    return r.kind === "accepted" || r.kind === "held";
+}
 /**
  * The Rotate phase after a revocation at control sequence `revokedAt`
  * (§8.2, §8.4, §9.2–§9.4), journaled in `operation`. The KEY_EPOCH is
@@ -177,7 +219,10 @@ export async function rotateAfter(o) {
                 : "awaiting-rotation";
         },
         build: async (chain) => {
-            const frontier = await verifiedFrontier(o.channel, chain, await localAccepted(o, chain));
+            const frontier = await verifiedFrontier(o.channel, chain, await localAccepted(o, chain), {
+                deks: await fetchDeks(o.storage, o.secrets, o.channel, chain, o.installation),
+                ...profileFor(o, chain),
+            });
             const dek = (await getPendingDek(o.secrets, R, o.operation)) ?? generateResourceDEK();
             // The DEK before the record that commits to it (§9.1).
             await putPendingDek(o.secrets, R, o.operation, dek);
@@ -233,6 +278,11 @@ export async function rotateAfter(o) {
  * stored accepted units and verified Snapshots, when the storage keeps them),
  * merged into the verified frontier (§8.3).
  */
+/** The codec the application gave for the Resource's Data Profile, if any. */
+const profileFor = (o, chain) => {
+    const profile = o.dataProfiles?.find((p) => p.dataProfile === chain.state.dataProfile);
+    return profile === undefined ? {} : { profile };
+};
 async function localAccepted(o, chain) {
     const st = o.storage;
     if (st.dataUnits === undefined || st.snapshots === undefined)
@@ -256,7 +306,20 @@ async function localAccepted(o, chain) {
     ])
         for (const u of await st.dataUnits.withStatus(R, status))
             units.push(u.bytes);
-    return { units, snapshot: await snapshotFrontier(st, R) };
+    // What this installation decided as a receiver. Proven bad bytes: AEAD and
+    // profile decode failures (a missing or wrong DEK is verified again). Accepted
+    // on the wire: the units its actor chain links through, a unit the profile
+    // refused when merging included (it keeps the accepted mark).
+    const refused = new Set();
+    for (const u of await st.dataUnits.withStatus(R, "local-failure"))
+        if (/^(AEAD|PROFILE_REJECTED):/.test(u.detail ?? ""))
+            refused.add(toHex(u.unitId));
+    const accepted = new Set();
+    for (const status of ["merged", "profile-pending", "profile-held", "profile-rejected"])
+        for (const u of await st.dataUnits.withStatus(R, status))
+            if (u.accepted)
+                accepted.add(toHex(u.unitId));
+    return { units, snapshot: await snapshotFrontier(st, R), refused, accepted };
 }
 /**
  * Resumes every rotation a journaled operation started and did not adopt:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openlfcp/client",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "LFCP client: session, Control Plane and Data Plane synchronization.",
   "keywords": [
     "openlfcp",
@@ -42,9 +42,9 @@
     "tag": "latest"
   },
   "dependencies": {
-    "@openlfcp/core": "^0.3.0",
-    "@openlfcp/storage": "^0.3.0",
-    "@openlfcp/crypto": "^0.3.0",
-    "@openlfcp/wire": "^0.3.0"
+    "@openlfcp/core": "^0.3.1",
+    "@openlfcp/crypto": "^0.3.1",
+    "@openlfcp/storage": "^0.3.1",
+    "@openlfcp/wire": "^0.3.1"
   }
 }