ftown 0.20.8 → 0.21.0

package/dist/security/bridge/policy.d.ts

@@ -1,16 +1,27 @@
 import type { ApprovedEndpoint, BridgeInvitation, EndpointPermission, EndpointPublic, EnrollmentMessage, InvitationOptions, LocalRecoveryAuthority, VerifiedPrincipal } from '../protocol.js';
-import type { AccountHead, AccountHistory, StoredAccountTrust, VerifiedAccountTrust } from '../account-protocol.js';
-import type { SecurityErrorCode } from '../protocol.js';
-/** Pre-removal policy files carry `mcp: []`, mcp devices and mcp provenance; the strict schema would reject them and brick the bridge. */
+import { type LedgerCheckpoint } from '../ledger/protocol.js';
+/** Pre-removal policy files carry `mcp: []`, mcp devices and mcp provenance; the strict schema would reject them and brick the bridge.
+ *  Files written before the ledger carry `account: null` (Solo/local always did): dropped. A non-null v1 account section is kept, so
+ *  the strict schema refuses it: v1 account state is never reinterpreted (startup resets such a bridge's identity instead). */
 export declare function migrateLegacyPolicy(raw: unknown): unknown;
 /** Identity comparison matters: request JSON cannot manufacture this recovery capability. */
 export declare const LOCAL_RECOVERY_AUTHORITY: LocalRecoveryAuthority;
 export interface PolicyOptions {
     now?: () => number;
-    monotonicNow?: () => number;
     relayUrl?: string;
     localOrigin?: string;
 }
+/** This bridge in its trusted ledger: 'unpaired' = no ledger stored, 'absent' = not listed with exactly its keys (or another
+ *  account's ledger), 'revoked' = its bridgeId is revoked (signed, or sticky from any chain the replica kept or adopted). */
+export type LedgerOwnStatus = 'active' | 'revoked' | 'absent' | 'unpaired';
+/** The account-mode authority, held in memory and replaced only by BridgeSecurityService. */
+export interface LedgerView {
+    /** applyRevocations(checkpoint, sticky) of the stored chain; null while no ledger is stored. Never the raw checkpoint. */
+    trusted: LedgerCheckpoint | null;
+    own: LedgerOwnStatus;
+    /** The ledger store's lastServerReadAt (null = never). Read once, on the first projection; afterwards contacts set it. */
+    lastServerReadAt: number | null;
+}
 /** Bridge-owned authorization. Directory entries and caller-claimed permissions never enter this store. */
 export declare class BridgePolicyStore {
     readonly bridgeId: string;
@@ -18,10 +29,22 @@ export declare class BridgePolicyStore {
     private readonly options;
     private readonly snapshot;
     private readonly now;
-    private readonly connectivity;
+    private readonly clockFile;
+    /** Account mode (enableLedger): null for Solo and --local, whose devices come only from invitations and the local CLI. */
+    private ledger;
     constructor(dataDir: string, bridgeId: string, bridge: EndpointPublic, options?: PolicyOptions);
     private check;
     private active;
+    /** Account mode. A revoked id is never trusted again. The OS-local CLI stays outside the ledger; every other endpoint must be a
+     *  projected ledger device that the CURRENT trusted view lists with the same key, while this bridge is active and in offline grace. */
+    private ledgerAccess;
+    /** Written so that NaN, an unknown contact or an unread clock file fails closed. A passing check raises the high-water. */
+    private withinGrace;
+    /** Loads the persisted high-water once (absent: none; unreadable: a contact in this process is then required). */
+    private loadClock;
+    /** Persists the observed high-water (after a contact, and on close). An unreadable file is only replaced after a fresh contact. */
+    persistLedgerClock(): Promise<void>;
+    private refuseInAccountMode;
     private principalFrom;
     private authorize;
     principal(endpointId: string): Promise<VerifiedPrincipal>;
@@ -32,21 +55,19 @@ export declare class BridgePolicyStore {
     recipients(): Promise<ApprovedEndpoint[]>;
     revoke(actor: VerifiedPrincipal, endpointId: string): Promise<void>;
     provisionLocalEndpoint(endpoint: EndpointPublic): Promise<void>;
-    accountTrust(): Promise<StoredAccountTrust | null>;
-    accountEndpointIds(): Promise<string[]>;
-    blockAccount(code: SecurityErrorCode): void;
-    accountAvailable(): Promise<boolean>;
-    /** Trusted startup bootstrap only; no remote endpoint can call this entry point. */
-    pinBootstrap(trust: VerifiedAccountTrust): Promise<void>;
-    private requireOwnBridge;
-    private projectAccount;
-    /** Only an authenticated API read reaches here; browser-supplied timestamps never do. */
-    applyAccountRead(history: AccountHistory, adoption?: {
-        actor: VerifiedPrincipal;
-        head: AccountHead;
-    }): Promise<{
-        head: AccountHead;
-        revoked: string[];
-    }>;
+    /** Enters account mode for this instance (irreversible): until projectLedger supplies a view, every non-local endpoint fails closed,
+     *  and invitations are refused. Only BridgeSecurityService calls this, with a ledger configured. */
+    enableLedger(now: () => number, monotonic: () => number): void;
+    /**
+     * Account mode only. Installs `view` synchronously (a revocation never waits for the write below), then makes the provenance-'account'
+     * devices exactly `view.trusted.devices` (none when trusted is null or another account's). Devices of any other provenance are never
+     * touched, and a ledger device whose id is already held by one is skipped. Returns the endpoint ids that lost account membership.
+     * `view.lastServerReadAt` is taken only on the first projection; later contacts come from noteServerRead.
+     */
+    projectLedger(view: LedgerView): Promise<string[]>;
+    /** Account mode: a successful server contact at wall time `at` re-anchors offline grace (lastServerReadAt = at, even if earlier: a
+     *  contact stamped during a forward clock jump never outlives its correction), restarts the monotonic bound and raises the high-water.
+     *  Returns `at`, or null (nothing changed) outside account mode or for an invalid time. */
+    noteServerRead(at: number): number | null;
     close(): Promise<void>;
 }

package/dist/security/bridge/policy.js

@@ -1,23 +1,27 @@
 import { legacyDateTimeSchema } from '../../zod-compat.js';
 import { createHash, randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
-import { join } from 'node:path';
+import { mkdir, open, rename, rm } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
 import { z } from 'zod';
 import { BridgeSecurityError } from './errors.js';
 import { approvedSchema, displayLabel, endpointSchema, permissionSchema } from './metadata.js';
 import { AtomicSnapshot } from './snapshot.js';
-import { verifyAccountHistory } from '../account-crypto.js';
-import { AccountConnectivity, storedAccountSchema } from './account-state.js';
+import { LEDGER_LIMITS } from '../ledger/protocol.js';
 const FIVE_MINUTES = 300_000;
 const MAX_ENDPOINTS = 1000;
 const digest = (secret) => createHash('sha256').update(secret).digest('hex');
 const invitationSchema = z.object({ id: z.string().guid(), secretHash: z.string().regex(/^[a-f0-9]{64}$/),
     label: z.string().max(100), permissions: z.array(permissionSchema).max(3), expiresAt: legacyDateTimeSchema,
-    consumedBy: z.string().nullable(), provenance: z.enum(['legacy', 'local-recovery']).default('legacy') }).strict();
-/** Pre-removal policy files carry `mcp: []`, mcp devices and mcp provenance; the strict schema would reject them and brick the bridge. */
+    consumedBy: z.string().nullable(), provenance: z.literal('legacy').default('legacy') }).strict();
+/** Pre-removal policy files carry `mcp: []`, mcp devices and mcp provenance; the strict schema would reject them and brick the bridge.
+ *  Files written before the ledger carry `account: null` (Solo/local always did): dropped. A non-null v1 account section is kept, so
+ *  the strict schema refuses it: v1 account state is never reinterpreted (startup resets such a bridge's identity instead). */
 export function migrateLegacyPolicy(raw) {
     if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
         return raw;
     const { mcp: _mcp, ...rest } = raw;
+    if (rest.account === null)
+        delete rest.account;
     const isMcpDevice = (device) => typeof device === 'object' && device !== null
         && device.endpoint?.kind === 'mcp';
     const dropped = new Set();
@@ -40,8 +44,8 @@ const policySchema = z.preprocess(migrateLegacyPolicy, z.object({ version: z.lit
     invitations: z.array(invitationSchema).max(256),
     // Frozen: earlier releases require this key, so a downgrade must still parse what we write.
     mcp: z.array(z.never()).max(0).default([]),
-    account: storedAccountSchema.nullable().default(null),
-    provenance: z.record(z.string(), z.enum(['legacy', 'local-recovery', 'account', 'local-cli'])).default({}),
+    // 'account': projected from the ledger replica (account mode only). 'legacy': enrolled by invitation. 'local-cli': OS-local CLI.
+    provenance: z.record(z.string(), z.enum(['legacy', 'account', 'local-cli'])).default({}),
 }).strict().superRefine((state, context) => {
     if (new Set(state.devices.map(device => device.endpoint.id)).size !== state.devices.length
         || state.devices.some(device => device.endpoint.ownerId !== state.ownerId
@@ -52,6 +56,59 @@ const policySchema = z.preprocess(migrateLegacyPolicy, z.object({ version: z.lit
 }));
 /** Identity comparison matters: request JSON cannot manufacture this recovery capability. */
 export const LOCAL_RECOVERY_AUTHORITY = Object.freeze({ source: 'os-local-recovery' });
+const isTime = (value) => value !== null && Number.isSafeInteger(value) && value >= 0;
+const CLOCK_KEYS = ['version', 'observedAt'];
+async function readClock(file) {
+    let text;
+    try {
+        const handle = await open(file, 'r');
+        try {
+            if ((await handle.stat()).size > 4096)
+                return 'corrupt';
+            text = await handle.readFile('utf8');
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch (error) {
+        return error.code === 'ENOENT' ? 'absent' : 'corrupt';
+    }
+    try {
+        const value = JSON.parse(text);
+        if (typeof value !== 'object' || value === null || Array.isArray(value))
+            return 'corrupt';
+        const record = value;
+        const keys = Object.keys(record);
+        const observedAt = record.observedAt;
+        if (keys.length !== CLOCK_KEYS.length || keys.some(key => !CLOCK_KEYS.includes(key)) || record.version !== 1
+            || typeof observedAt !== 'number' || !isTime(observedAt))
+            return 'corrupt';
+        return observedAt;
+    }
+    catch {
+        return 'corrupt';
+    }
+}
+async function writeClock(file, observedAt) {
+    const temporary = `${file}.${randomUUID()}.tmp`;
+    try {
+        await mkdir(dirname(file), { recursive: true, mode: 0o700 });
+        const handle = await open(temporary, 'wx', 0o600);
+        try {
+            await handle.writeFile(JSON.stringify({ version: 1, observedAt }));
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        await rename(temporary, file);
+    }
+    catch {
+        await rm(temporary, { force: true }).catch(() => undefined);
+        throw new BridgeSecurityError('storage_unavailable');
+    }
+}
 /** Bridge-owned authorization. Directory entries and caller-claimed permissions never enter this store. */
 export class BridgePolicyStore {
     bridgeId;
@@ -59,7 +116,9 @@ export class BridgePolicyStore {
     options;
     snapshot;
     now;
-    connectivity;
+    clockFile;
+    /** Account mode (enableLedger): null for Solo and --local, whose devices come only from invitations and the local CLI. */
+    ledger = null;
     constructor(dataDir, bridgeId, bridge, options = {}) {
         this.bridgeId = bridgeId;
         this.bridge = bridge;
@@ -68,10 +127,10 @@ export class BridgePolicyStore {
         if (bridge.kind !== 'bridge')
             throw new BridgeSecurityError('wrong_context');
         this.now = options.now ?? Date.now;
-        this.connectivity = new AccountConnectivity(this.now, options.monotonicNow ?? (() => performance.now()));
+        this.clockFile = join(dataDir, 'security', 'ledger-clock.json');
         this.snapshot = new AtomicSnapshot(join(dataDir, 'security', 'policy.json'), policySchema, () => ({
             version: 1, ownerId: bridge.ownerId, bridgeId, bridgeEndpointId: bridge.id, generation: 0,
-            devices: [], invitations: [], mcp: [], account: null, provenance: {},
+            devices: [], invitations: [], mcp: [], provenance: {},
         }));
     }
     check(state) {
@@ -81,23 +140,89 @@ export class BridgePolicyStore {
     }
     active(state, endpointId) {
         this.check(state);
-        const account = state.account;
-        const member = account?.checkpoint.devices.find(item => item.endpoint.id === endpointId);
-        if (member) {
-            this.connectivity.check(account);
-            const own = account.checkpoint.bridges.find(item => item.bridgeId === this.bridgeId);
-            if (!own || own.endpoint.id !== this.bridge.id || own.endpoint.publicKey !== this.bridge.publicKey)
-                throw new BridgeSecurityError('account_bridge_revoked');
-        }
-        else if (account?.checkpoint.revokedDeviceIds.includes(endpointId))
-            throw new BridgeSecurityError('account_device_revoked');
         const record = state.devices.find(device => device.endpoint.id === endpointId);
+        if (this.ledger)
+            this.ledgerAccess(state, endpointId, record);
+        // Without a ledger nothing vouches for a projected account device: it never authorizes.
+        else if (state.provenance[endpointId] === 'account')
+            throw new BridgeSecurityError('approval_required');
         if (!record)
             throw new BridgeSecurityError('approval_required');
         if (record.expiresAt && Date.parse(record.expiresAt) <= this.now())
             throw new BridgeSecurityError('expired');
         return record;
     }
+    /** Account mode. A revoked id is never trusted again. The OS-local CLI stays outside the ledger; every other endpoint must be a
+     *  projected ledger device that the CURRENT trusted view lists with the same key, while this bridge is active and in offline grace. */
+    ledgerAccess(state, endpointId, record) {
+        const view = this.ledger.view;
+        if (view.trusted?.revokedDeviceIds.includes(endpointId))
+            throw new BridgeSecurityError('account_device_revoked');
+        if (!record || record.endpoint.kind === 'local-cli')
+            return;
+        if (state.provenance[endpointId] !== 'account')
+            throw new BridgeSecurityError('approval_required');
+        if (view.trusted === null)
+            throw new BridgeSecurityError('account_offline_expired');
+        if (view.own !== 'active')
+            throw new BridgeSecurityError('account_bridge_revoked');
+        if (!this.withinGrace())
+            throw new BridgeSecurityError('account_offline_expired');
+        const member = view.trusted.devices.find(item => item.endpoint.id === endpointId);
+        if (!member || member.endpoint.publicKey !== record.endpoint.publicKey)
+            throw new BridgeSecurityError('account_device_revoked');
+    }
+    /** Written so that NaN, an unknown contact or an unread clock file fails closed. A passing check raises the high-water. */
+    withinGrace() {
+        const gate = this.ledger;
+        const at = gate.now();
+        const monotonic = gate.monotonic();
+        const last = gate.lastServerReadAt;
+        const { offlineGraceMs: grace, maxFutureSkewMs: skew } = LEDGER_LIMITS;
+        const within = gate.clock !== 'loading' && (gate.clock === 'trusted' || gate.contactAt !== null)
+            && isTime(last) && Number.isSafeInteger(at)
+            // The wall clock went back before the last contact, or before a time this bridge already observed (also across restarts).
+            && at >= last - skew && at >= gate.highWater - skew
+            && at - last <= grace
+            && (gate.contactAt === null || (Number.isFinite(monotonic) && monotonic >= gate.contactAt && monotonic - gate.contactAt <= grace));
+        if (within && at > gate.highWater)
+            gate.highWater = at;
+        return within;
+    }
+    /** Loads the persisted high-water once (absent: none; unreadable: a contact in this process is then required). */
+    loadClock() {
+        const gate = this.ledger;
+        gate.clockLoad ??= readClock(this.clockFile).then(stored => {
+            if (typeof stored === 'number') {
+                gate.highWater = Math.max(gate.highWater, stored);
+                gate.persisted = stored;
+            }
+            gate.clock = stored === 'corrupt' ? 'untrusted' : 'trusted';
+        });
+        return gate.clockLoad;
+    }
+    /** Persists the observed high-water (after a contact, and on close). An unreadable file is only replaced after a fresh contact. */
+    async persistLedgerClock() {
+        const gate = this.ledger;
+        if (!gate)
+            return;
+        await this.loadClock();
+        if (gate.clock === 'untrusted' && gate.contactAt === null)
+            return;
+        const write = gate.clockWrite.then(async () => {
+            const observedAt = gate.highWater;
+            if (observedAt <= gate.persisted)
+                return;
+            await writeClock(this.clockFile, observedAt);
+            gate.persisted = Math.max(gate.persisted, observedAt);
+        });
+        gate.clockWrite = write.catch(() => undefined);
+        await write;
+    }
+    refuseInAccountMode() {
+        if (this.ledger)
+            throw new BridgeSecurityError('account_managed');
+    }
     principalFrom(state, record) {
         return { endpoint: record.endpoint, bridgeId: this.bridgeId, permissions: record.permissions,
             policyGeneration: state.generation, grantId: record.grantId };
@@ -135,16 +260,15 @@ export class BridgePolicyStore {
         const expiresAt = new Date(this.now() + FIVE_MINUTES).toISOString();
         await this.snapshot.transact(state => {
             this.check(state);
-            if (actor !== LOCAL_RECOVERY_AUTHORITY) {
+            // Account mode: browsers join only through the ledger, whoever asks.
+            this.refuseInAccountMode();
+            if (actor !== LOCAL_RECOVERY_AUTHORITY)
                 this.authorize(state, actor, 'admin');
-                if (state.account && actor.endpoint.kind !== 'local-cli')
-                    throw new BridgeSecurityError('account_approval_required');
-            }
             state.invitations = state.invitations.filter(invitation => Date.parse(invitation.expiresAt) > this.now());
             if (state.invitations.length >= 256)
                 throw new BridgeSecurityError('capacity_exceeded');
             state.invitations.push({ id: invitationId, secretHash: digest(secret), label: displayLabel(options.label),
-                permissions: ['read', 'control', 'admin'], expiresAt, consumedBy: null, provenance: state.account ? 'local-recovery' : 'legacy' });
+                permissions: ['read', 'control', 'admin'], expiresAt, consumedBy: null, provenance: 'legacy' });
         });
         return { version: 1, invitationId, ownerId: this.bridge.ownerId, bridgeId: this.bridgeId, bridge: this.bridge,
             secret, expiresAt, relayUrl: this.options.relayUrl ?? null, localOrigin: this.options.localOrigin ?? null };
@@ -162,18 +286,13 @@ export class BridgePolicyStore {
             throw new BridgeSecurityError('invitation_invalid');
         return this.snapshot.transact(state => {
             this.check(state);
+            this.refuseInAccountMode();
             const invitation = state.invitations.find(item => item.id === message.invitationId);
             if (!invitation || !timingSafeEqual(Buffer.from(invitation.secretHash), Buffer.from(digest(message.invitationSecret)))) {
                 throw new BridgeSecurityError('invitation_invalid');
             }
             if (Date.parse(invitation.expiresAt) <= this.now())
                 throw new BridgeSecurityError('invitation_expired');
-            if (state.account && invitation.provenance !== 'local-recovery')
-                throw new BridgeSecurityError('invitation_invalid');
-            // Independent recovery must never shadow an account membership or revive its tombstone.
-            if (state.account && (state.account.checkpoint.devices.some(item => item.endpoint.id === candidate.id)
-                || state.account.checkpoint.revokedDeviceIds.includes(candidate.id)))
-                throw new BridgeSecurityError('account_approval_required');
             if (invitation.consumedBy) {
                 if (invitation.consumedBy !== candidate.id)
                     throw new BridgeSecurityError('invitation_consumed');
@@ -200,7 +319,7 @@ export class BridgePolicyStore {
                 const provenance = state.provenance[device.endpoint.id];
                 if (provenance === 'account')
                     return { ...device, source: 'account' };
-                if (provenance === 'local-cli' || provenance === 'local-recovery')
+                if (provenance === 'local-cli')
                     return { ...device, source: 'local' };
                 return { ...device };
             });
@@ -222,8 +341,10 @@ export class BridgePolicyStore {
     async revoke(actor, endpointId) {
         await this.snapshot.transact(state => {
             this.authorize(state, actor, 'admin');
-            if (state.account?.checkpoint.devices.some(item => item.endpoint.id === endpointId))
-                throw new BridgeSecurityError('account_approval_required');
+            // A ledger device leaves only by a passkey-signed revoke_device; the bridge never drops it on request.
+            if (this.ledger && (state.provenance[endpointId] === 'account'
+                || this.ledger.view.trusted?.devices.some(item => item.endpoint.id === endpointId)))
+                throw new BridgeSecurityError('account_managed');
             state.devices = state.devices.filter(device => device.endpoint.id !== endpointId);
             delete state.provenance[endpointId];
             state.generation++;
@@ -245,116 +366,77 @@ export class BridgePolicyStore {
             state.provenance[candidate.id] = 'local-cli';
         });
     }
-    async accountTrust() {
-        return this.snapshot.read(state => { this.check(state); return state.account; });
-    }
-    async accountEndpointIds() {
-        return this.snapshot.read(state => { this.check(state); return state.account?.checkpoint.devices.map(item => item.endpoint.id) ?? []; });
+    /** Enters account mode for this instance (irreversible): until projectLedger supplies a view, every non-local endpoint fails closed,
+     *  and invitations are refused. Only BridgeSecurityService calls this, with a ledger configured. */
+    enableLedger(now, monotonic) {
+        this.ledger ??= { view: { trusted: null, own: 'unpaired' }, now, monotonic, loaded: false, lastServerReadAt: null, contactAt: null,
+            highWater: 0, persisted: 0, clock: 'loading', clockLoad: null, clockWrite: Promise.resolve() };
     }
-    blockAccount(code) { this.connectivity.block(code); }
-    async accountAvailable() {
-        return this.snapshot.read(state => {
+    /**
+     * Account mode only. Installs `view` synchronously (a revocation never waits for the write below), then makes the provenance-'account'
+     * devices exactly `view.trusted.devices` (none when trusted is null or another account's). Devices of any other provenance are never
+     * touched, and a ledger device whose id is already held by one is skipped. Returns the endpoint ids that lost account membership.
+     * `view.lastServerReadAt` is taken only on the first projection; later contacts come from noteServerRead.
+     */
+    projectLedger(view) {
+        const ledger = this.ledger;
+        if (!ledger)
+            return Promise.reject(new BridgeSecurityError('wrong_context'));
+        const trusted = view.trusted !== null && view.trusted.accountId === this.bridge.ownerId ? view.trusted : null;
+        ledger.view = { trusted, own: trusted === null && view.own === 'active' ? 'absent' : view.own };
+        if (!ledger.loaded) {
+            ledger.loaded = true;
+            ledger.lastServerReadAt = isTime(view.lastServerReadAt) ? view.lastServerReadAt : null;
+        }
+        const clock = this.loadClock();
+        const members = trusted === null ? [] : trusted.devices;
+        return clock.then(() => this.snapshot.transact(state => {
             this.check(state);
-            if (!state.account)
-                return true;
-            try {
-                this.connectivity.check(state.account);
-                return state.account.checkpoint.bridges.some(item => item.bridgeId === this.bridgeId && item.endpoint.id === this.bridge.id);
-            }
-            catch {
+            const removed = [];
+            state.devices = state.devices.filter(device => {
+                const id = device.endpoint.id;
+                if (state.provenance[id] !== 'account')
+                    return true;
+                const member = members.find(item => item.endpoint.id === id);
+                if (member && member.endpoint.publicKey === device.endpoint.publicKey)
+                    return true;
+                removed.push(id);
+                delete state.provenance[id];
                 return false;
-            }
-        });
-    }
-    /** Trusted startup bootstrap only; no remote endpoint can call this entry point. */
-    async pinBootstrap(trust) {
-        await this.snapshot.transact(async (state) => {
-            this.check(state);
-            if (state.account) {
-                if (state.account.checkpoint.rootId !== trust.checkpoint.rootId)
-                    throw new BridgeSecurityError('account_trust_rollback');
-                return;
-            }
-            const checkpoint = await verifyAccountHistory(trust.history, trust.checkpoint, this.now());
-            this.requireOwnBridge(checkpoint);
-            this.projectAccount(state, { ...trust, checkpoint, lastServerReadAt: 0, lastObservedAt: 0 });
-        });
-    }
-    requireOwnBridge(checkpoint) {
-        const own = checkpoint.bridges.find(item => item.bridgeId === this.bridgeId);
-        if (checkpoint.ownerId !== this.bridge.ownerId || !own || own.endpoint.id !== this.bridge.id
-            || own.endpoint.publicKey !== this.bridge.publicKey || own.endpoint.ownerId !== this.bridge.ownerId)
-            throw new BridgeSecurityError('wrong_context');
-    }
-    projectAccount(state, trust) {
-        const previous = state.devices.filter(item => item.endpoint.kind === 'browser');
-        const first = state.account === null;
-        const unchanged = state.account?.checkpoint.head === trust.checkpoint.head;
-        state.devices = state.devices.filter(item => item.endpoint.kind !== 'browser'
-            || (!first && state.provenance[item.endpoint.id] === 'local-recovery'
-                && !trust.checkpoint.devices.some(member => member.endpoint.id === item.endpoint.id)
-                && !trust.checkpoint.revokedDeviceIds.includes(item.endpoint.id)));
-        if (first)
-            state.invitations = [];
-        for (const entry of previous)
-            if (!state.devices.some(item => item.endpoint.id === entry.endpoint.id))
-                delete state.provenance[entry.endpoint.id];
-        const own = trust.checkpoint.bridges.find(item => item.bridgeId === this.bridgeId);
-        if (own?.endpoint.id === this.bridge.id && own.endpoint.publicKey === this.bridge.publicKey) {
-            for (const member of trust.checkpoint.devices) {
-                if (state.devices.some(item => item.endpoint.id === member.endpoint.id))
-                    throw new BridgeSecurityError('wrong_context');
+            });
+            for (const member of members) {
+                if (state.devices.some(device => device.endpoint.id === member.endpoint.id))
+                    continue;
+                if (state.devices.length >= MAX_ENDPOINTS)
+                    throw new BridgeSecurityError('capacity_exceeded');
                 state.devices.push({ endpoint: member.endpoint, label: displayLabel(member.label), permissions: ['read', 'control', 'admin'],
-                    approvedAt: member.approvedAt, grantId: null, expiresAt: null });
+                    approvedAt: new Date(member.approvedAt).toISOString(), grantId: null, expiresAt: null });
                 state.provenance[member.endpoint.id] = 'account';
             }
-        }
-        state.account = trust;
-        if (!unchanged)
-            state.generation++;
-        return previous.filter(item => !state.devices.some(next => next.endpoint.id === item.endpoint.id)).map(item => item.endpoint.id);
+            // Never the global generation: a ledger change must not disturb the principals it leaves in place. A removed device is
+            // invalidated on its own: its record is gone (and the view refuses it), so its next principal/revalidate fails, and the
+            // caller emits onRevoked for it.
+            return removed;
+        }));
     }
-    /** Only an authenticated API read reaches here; browser-supplied timestamps never do. */
-    async applyAccountRead(history, adoption) {
-        const result = await this.snapshot.transact(async (state) => {
-            this.check(state);
-            if (!state.account && !adoption)
-                throw new BridgeSecurityError('account_approval_required');
-            if (adoption) {
-                if (adoption.actor.endpoint.kind !== 'browser')
-                    throw new BridgeSecurityError('permission_denied');
-                this.authorize(state, adoption.actor, 'admin');
-            }
-            const checkpoint = await verifyAccountHistory(history, state.account?.checkpoint ?? null, this.now());
-            if (checkpoint.ownerId !== this.bridge.ownerId)
-                throw new BridgeSecurityError('wrong_context');
-            if (adoption) {
-                const head = adoption.head;
-                if (head.rootId !== checkpoint.rootId || head.revision !== checkpoint.revision || head.head !== checkpoint.head)
-                    throw new BridgeSecurityError('account_trust_conflict');
-                this.requireOwnBridge(checkpoint);
-                const member = checkpoint.devices.find(item => item.endpoint.id === adoption.actor.endpoint.id);
-                if (!member || member.endpoint.publicKey !== adoption.actor.endpoint.publicKey || member.endpoint.ownerId !== adoption.actor.endpoint.ownerId) {
-                    throw new BridgeSecurityError('account_device_revoked');
-                }
-                this.authorize(state, adoption.actor, 'admin');
-            }
-            const initial = state.account ?? { checkpoint, history, lastServerReadAt: 0, lastObservedAt: 0 };
-            const now = this.connectivity.observed(initial);
-            const trust = { checkpoint, history, lastServerReadAt: Math.max(initial.lastServerReadAt, now),
-                lastObservedAt: Math.max(initial.lastObservedAt, now) };
-            const revoked = this.projectAccount(state, trust);
-            return { head: { rootId: checkpoint.rootId, revision: checkpoint.revision, head: checkpoint.head }, revoked, trust };
-        });
-        this.connectivity.renew(result.trust);
-        return { head: result.head, revoked: result.revoked };
+    /** Account mode: a successful server contact at wall time `at` re-anchors offline grace (lastServerReadAt = at, even if earlier: a
+     *  contact stamped during a forward clock jump never outlives its correction), restarts the monotonic bound and raises the high-water.
+     *  Returns `at`, or null (nothing changed) outside account mode or for an invalid time. */
+    noteServerRead(at) {
+        const ledger = this.ledger;
+        if (!ledger || !isTime(at))
+            return null;
+        ledger.loaded = true;
+        ledger.lastServerReadAt = at;
+        ledger.contactAt = ledger.monotonic();
+        if (at > ledger.highWater)
+            ledger.highWater = at;
+        return at;
     }
     async close() {
-        await this.snapshot.transact(state => {
-            this.check(state);
-            if (state.account)
-                state.account.lastObservedAt = Math.max(state.account.lastObservedAt, this.connectivity.highwater());
-        });
+        if (this.ledger) {
+            await this.persistLedgerClock().catch((error) => console.error('[Security] Saving the ledger clock failed:', error instanceof Error ? error.message : String(error)));
+        }
         await this.snapshot.close();
     }
 }