@openlfcp/client 0.3.0 → 0.4.0

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,7 @@
 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 { DataProfileHandler } from "../apply.js";
 import { type IdentityStorage, type Installation, type KeyDelivery } from "./context.js";
 import { type IdentityNetwork } from "./network.js";
 import { type LinearChain } from "./phases.js";
@@ -31,7 +32,25 @@ export interface FlowOptions {
     readonly secrets: SecretStore;
     readonly network: IdentityNetwork;
     readonly now: () => number;
+    /**
+     * The application's Data Profiles, each as its receiver checks one unit:
+     * `codecFor({resourceId, actor})`, the codec bound to the unit's Resource
+     * and signer (the DataProfileHandler hook; e.g. shared-objects'
+     * sharedObjectsUnitProfile, sectionsUnitProfile, identityUnitProfile). A
+     * rotation judges each unit with its Resource's profile, as recipients do
+     * (W §26.3 rules 6 and 7, including the change's actor); without one, only
+     * decryption and recorded refusals are checked. Replaces 0.3.1's
+     * `dataProfiles` (bare codecs, which cannot bind the actor): a flow given
+     * `dataProfiles` throws instead of checking less.
+     */
+    readonly profiles?: readonly UnitProfile[];
 }
+/**
+ * One Data Profile's per-unit check (the receiver's DataProfileHandler
+ * `dataProfile` and `codecFor`): `decode` of the codec it returns throws to
+ * reject the unit's plaintext.
+ */
+export type UnitProfile = Pick<DataProfileHandler<unknown>, "dataProfile" | "codecFor">;
 /**
  * The certificates above a leaf that `issuer` signs for `root` in the
  * state: none when the issuer is the root, else the issuer's own current

package/dist/identity/index.d.ts

@@ -1,7 +1,7 @@
 /** Identity flows (IDENTITY-PROFILE-01 §§5–9, LFCP-04-410). */
 export { acceptInvitationAsDevice, claimForRootRecord, createResourceAsDevice, type DeviceAcceptResult, type DeviceCreateResult, type DeviceResourceResult, type IncompleteDeviceResource, selfRegistrationRecord, } from "./accept.js";
 export { type DocumentWrite, deliverKeys, extendChain, fetchDeks, genesisOwner, heldDeks, IdentityConflict, type IdentityDocumentLoad, type IdentityStorage, type Installation, type KeyDelivery, loadIdentityDocument, type PhaseOutcome, readersAt, runControlPhase, runUnitPhase, sealIdentityUnit, storeDek, syncChain, } from "./context.js";
-export { checkIssuance, type Feasibility, type FlowOptions, issuerCertificates, leafPayload, MASK_PRESETS, type MaskPreset, mayManageDevices, type RegisterTarget, type RegistrationResult, type RegistrationStatus, registerDevice, signChain, } from "./devices.js";
+export { checkIssuance, type Feasibility, type FlowOptions, issuerCertificates, leafPayload, MASK_PRESETS, type MaskPreset, mayManageDevices, type RegisterTarget, type RegistrationResult, type RegistrationStatus, registerDevice, signChain, type UnitProfile, } from "./devices.js";
 export { type DeviceEntryValue, IDENTITY_PROFILE, type IdentityAuthor, type IdentityDocumentPort, type IdentityIntent, type IdentityWriterClass, identityPlaintextCodec, identityWriterClass, type PairingRequestValue, principalOfRef, principalRefOf, type RosterEntryValue, resourceRef, } from "./document.js";
 export { type JournalOperation, type JournalPhase, type LedgerEntry, OperationJournal, type OperationKind, type OperationStatus, PackageLedger, pairingSecretRef, pendingDekRef, } from "./journal.js";
 export { ChannelPool, type ConnectionNetworkOptions, connectionNetwork, IDENTITY_EXTENSION, type IdentityAnswer, type IdentityChannel, type IdentityNetwork, IdentityRefused, IdentityUnavailable, type OpenAnswer, } from "./network.js";
@@ -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/pairing.js

@@ -9,6 +9,7 @@ import { ChannelPool, IdentityUnavailable } from "./network.js";
 import { classifyCancel, classifyConsume, classifyRegister } from "./phases.js";
 import { identityTarget } from "./resource.js";
 import { rotateIfExposed } from "./revocation.js";
+import { checkFlowProfiles } from "./rotation.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
@@ -323,6 +324,7 @@ export async function pairingRequests(o) {
  * phase 1; phase 2 signs exactly that payload.
  */
 export async function approvePairing(o) {
+    checkFlowProfiles(o);
     const { I, R, J, url } = await readSession(o, o.review.session);
     const pool = new ChannelPool(o.network);
     const me = o.installation.signer;
@@ -413,6 +415,7 @@ export const approvedGrantRecord = (chain, signer, root, device, pairing) => sig
 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) {
+    checkFlowProfiles(o);
     const journal = new OperationJournal(o.storage);
     const pool = new ChannelPool(o.network);
     const me = o.installation.signer;
@@ -565,6 +568,7 @@ export async function resumeApproval(o, operation) {
  * human does not confirm is rejected).
  */
 export async function cancelPairing(o) {
+    checkFlowProfiles(o);
     const { I, R, J, url } = await readSession(o, o.session);
     const journal = new OperationJournal(o.storage);
     const pool = new ChannelPool(o.network);

package/dist/identity/reconcile.js

@@ -8,7 +8,7 @@ import { ChannelPool, IDENTITY_EXTENSION, IdentityRefused, IdentityUnavailable,
 import { classifyRegister, classifyRevoke } from "./phases.js";
 import { identityTarget } from "./resource.js";
 import { rotateIfExposed } from "./revocation.js";
-import { resumeRotations } from "./rotation.js";
+import { checkFlowProfiles, 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
@@ -98,6 +98,7 @@ export function reconcileRecord(target, step, signer) {
  * opened and this installation is the rotator, it rotates (§8.4).
  */
 export async function reconcileDevices(o) {
+    checkFlowProfiles(o);
     const target = await identityTarget(o);
     const me = o.installation.signer;
     const journal = new OperationJournal(o.storage);

package/dist/identity/revocation.js

@@ -7,7 +7,7 @@ import { newOperationId, OperationJournal, phaseOf } from "./journal.js";
 import { ChannelPool, IDENTITY_EXTENSION, IdentityRefused, IdentityUnavailable, } from "./network.js";
 import { classifyRevoke } from "./phases.js";
 import { identityTarget } from "./resource.js";
-import { exposingRevocationsSince, resumeRotations, rotateAfter, rotatorTest, } from "./rotation.js";
+import { checkFlowProfiles, exposingRevocationsSince, resumeRotations, rotateAfter, rotatorTest, } from "./rotation.js";
 const toKeep = (state, root) => [...state.devices.entries()]
     .filter(([, d]) => bytesEqual(d.root, root))
     .map(([hex]) => principalId(fromHex(hex)))
@@ -131,6 +131,7 @@ class SelfDependent extends Error {
  * another reason is `complete` and the rotation test still runs.
  */
 export async function revokeDevice(o) {
+    checkFlowProfiles(o);
     const target = await identityTarget(o);
     const me = o.installation.signer.descriptor.principalId;
     const selfRetire = bytesEqual(me, o.device);
@@ -387,6 +388,7 @@ async function markRevoked(o, channel, journal, operation, I, device) {
  * nothing exposing happened since the last rotation.
  */
 export async function rotateIfExposed(o) {
+    checkFlowProfiles(o);
     // A rotation this operation already started resumes from its journaled phase: its
     // KEY_EPOCH may be committed while its DEK still waits in the pending slot (§9.1).
     const started = phaseOf(await new OperationJournal(o.storage).load(o.operation), `rotate:${toHex(o.resource)}`);

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,7 +1,8 @@
 import { type ControlRecordId, type DataEpoch, type PrincipalId, type ResourceId } from "@openlfcp/core";
+import { type ResourceDEK } from "@openlfcp/crypto";
 import { type ControlState, type HaveVector, type PrincipalDescriptor } from "@openlfcp/wire";
 import { type KeyDelivery } from "./context.js";
-import type { FlowOptions } from "./devices.js";
+import type { FlowOptions, UnitProfile } from "./devices.js";
 import { type ChannelPool, type IdentityChannel } from "./network.js";
 import { type LinearChain } from "./phases.js";
 /**
@@ -40,15 +41,47 @@ 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, when the application gives it, as its
+     * receiver checks one unit: `codecFor({resourceId, actor})` is bound to the
+     * unit's Resource and signer, and the codec's `decode` is the profile's
+     * acceptance (the change's actor included). Without it only decryption is
+     * checked here, and a profile refusal this installation recorded still
+     * counts (LocalAccepted.refused). 0.3.1 took a bare codec, which cannot
+     * bind the actor: one without `codecFor` is refused (TypeError).
+     */
+    readonly profile?: UnitProfile;
 }
 export type RotationStatus = 
 /** This installation committed the KEY_EPOCH and sealed the new DEK to every reader. */
@@ -87,6 +120,8 @@ export declare function rotateAfter(o: FlowOptions & {
     readonly resource: ResourceId;
     readonly revokedAt: bigint;
 }): Promise<RotationOutcome>;
+/** The flow options of a rotation: 0.3.1's bare `dataProfiles` is refused, never checked less. */
+export declare function checkFlowProfiles(o: FlowOptions): void;
 /**
  * Resumes every rotation a journaled operation started and did not adopt:
  * a KEY_EPOCH whose ACK was lost leaves its DEK in the operation's pending

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,16 @@ 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) {
+    if (data?.profile !== undefined)
+        checkUnitProfile(data.profile, "FrontierData.profile");
     const R = chain.state.resourceId;
     const opened = await channel.open(R);
     const ranges = opened.kind === "nack"
@@ -90,10 +97,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), p.actor, 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 +154,34 @@ 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, actor, local, data) {
+    if (local.accepted?.has(unitId) === true)
+        return true;
+    if (local.refused?.has(unitId) === true)
+        return false;
+    // The receiver's own check of this unit: bound to its Resource and signer (W §26.3 rule 7).
+    const profile = data.profile !== undefined && data.profile.dataProfile === chain.state.dataProfile
+        ? data.profile.codecFor({ resourceId: chain.state.resourceId, actor })
+        : 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
@@ -149,6 +194,7 @@ function coveredTop(vector, actor) {
  * readers and receive nothing.
  */
 export async function rotateAfter(o) {
+    checkFlowProfiles(o);
     const journal = new OperationJournal(o.storage);
     const me = o.installation.signer;
     const R = o.resource;
@@ -177,7 +223,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 +282,28 @@ export async function rotateAfter(o) {
  * stored accepted units and verified Snapshots, when the storage keeps them),
  * merged into the verified frontier (§8.3).
  */
+/** The profile the application gave for the Resource's Data Profile, if any. */
+const profileFor = (o, chain) => {
+    const profile = o.profiles?.find((p) => p.dataProfile === chain.state.dataProfile);
+    return profile === undefined ? {} : { profile };
+};
+/**
+ * A profile given where a per-unit check is needed must be one: a bare codec
+ * (0.3.1's FlowOptions.dataProfiles, FrontierData.profile) cannot bind the
+ * change's actor to the unit's signer, so it is refused, never used as a
+ * weaker check (W §26.3 rule 7).
+ */
+function checkUnitProfile(profile, where) {
+    if (typeof profile.codecFor !== "function")
+        throw new TypeError(`${where} needs a per-unit profile (dataProfile and codecFor({resourceId, actor})), not a bare codec`);
+}
+/** The flow options of a rotation: 0.3.1's bare `dataProfiles` is refused, never checked less. */
+export function checkFlowProfiles(o) {
+    if (o.dataProfiles !== undefined)
+        throw new TypeError("FlowOptions.dataProfiles (bare codecs, 0.3.1) is replaced by FlowOptions.profiles (codecFor per unit): a codec without the unit's signer cannot check the change's actor");
+    for (const p of o.profiles ?? [])
+        checkUnitProfile(p, "FlowOptions.profiles");
+}
 async function localAccepted(o, chain) {
     const st = o.storage;
     if (st.dataUnits === undefined || st.snapshots === undefined)
@@ -256,7 +327,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:
@@ -265,6 +349,7 @@ async function localAccepted(o, chain) {
  * it (§9.1, §9.2). Run before planning new work on a Resource.
  */
 export async function resumeRotations(o) {
+    checkFlowProfiles(o);
     const journal = new OperationJournal(o.storage);
     const out = [];
     for (const op of await journal.list())

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openlfcp/client",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "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.4.0",
+    "@openlfcp/storage": "^0.4.0",
+    "@openlfcp/wire": "^0.4.0",
+    "@openlfcp/crypto": "^0.4.0"
   }
 }