@tearleads/client-sdk 0.1.61 → 0.1.63

package/workflows/principals/publicPrincipalHistoryProgress.js

@@ -1,179 +0,0 @@
-import { createPrincipalPolicyHistoryVerifier, KeyingVerificationError, restorePrincipalPolicyHistoryVerifier, serializeKeyingCanonicalJson, verifyPrincipalPolicyHistoryReferences, } from "../../internal/crypto/index.js";
-import { isReferencedPrincipalStateResponse } from "../../internal/validators/response/index.js";
-import { loadPrincipalHistoryReference } from "../../data/persistence/principalHistoryEvidencePersistence.js";
-import { discardPrincipalHistoryPrefix, loadPrincipalHistoryPrefix, savePrincipalHistoryPrefix, } from "../../data/persistence/principalHistoryPrefixPersistence.js";
-import { discardPrincipalHistoryStage, loadPrincipalHistoryStage, } from "../../data/persistence/principalHistoryStagePersistence.js";
-import { principalHeadMatchesReference } from "../../data/principals/organizationAuthorityDescriptor.js";
-import { principalHistoryEvidenceScopeId, principalHistoryPrefixProtection, } from "../../data/principals/principalHistoryPrefixProtection.js";
-import { principalHistoryStageId, principalHistoryStageProtection, } from "../../data/principals/principalHistoryStageProtection.js";
-import { PublicHistoryAuthorityUnavailableError, parsePublicHistoryAuthority, publicHistoryAuthorityJson, validatePublicHistoryAuthority, } from "./publicPrincipalHistoryAuthority.js";
-async function restorePublicPrefix(input, scopeId, id, prefix) {
-    const head = input.source.head;
-    const historyInput = {
-        principalType: head.principalType,
-        principalId: head.principalId,
-    };
-    const current = () => !input.signal?.aborted && input.stillCurrent();
-    if (prefix) {
-        const authorityReference = parsePublicHistoryAuthority(input, prefix.currentJson);
-        let prefixHead;
-        try {
-            prefixHead = JSON.parse(prefix.headJson);
-        }
-        catch {
-            prefixHead = null;
-        }
-        if (prefix.organizationId === input.organizationId &&
-            authorityReference !== undefined &&
-            isReferencedPrincipalStateResponse(prefixHead) &&
-            prefixHead.principalId === head.principalId &&
-            prefixHead.principalType === head.principalType &&
-            prefixHead.version === prefix.version) {
-            const restored = await restorePrincipalPolicyHistoryVerifier(historyInput, prefix.progress, await principalHistoryPrefixProtection(input.protection, prefix));
-            if (restored.ok && restored.value.finish(prefixHead).ok) {
-                await validatePublicHistoryAuthority(input, authorityReference, prefix);
-                return {
-                    id,
-                    scopeId,
-                    verifier: restored.value,
-                    completedHead: prefixHead.version >= head.version ? prefixHead : null,
-                    afterVersion: Math.min(prefixHead.version, head.version - 1),
-                    saved: null,
-                    cachedPrefix: prefix,
-                    authorityReference,
-                };
-            }
-        }
-        if (!input.offline)
-            await discardPrincipalHistoryPrefix({
-                execSql: input.execSql,
-                prefix,
-                stillCurrent: current,
-            });
-    }
-    return null;
-}
-export async function restorePublicPrincipalHistoryProgress(input, allowReuse) {
-    const head = input.source.head;
-    const historyInput = {
-        principalType: head.principalType,
-        principalId: head.principalId,
-    };
-    const scopeId = await principalHistoryEvidenceScopeId({
-        organizationId: input.organizationId,
-        head,
-        protection: input.protection,
-    });
-    const id = await principalHistoryStageId(input.organizationId, head, input.protection.context);
-    const current = () => !input.signal?.aborted && input.stillCurrent();
-    const saved = await loadPrincipalHistoryStage(input.execSql, id);
-    if (saved) {
-        const authorityReference = parsePublicHistoryAuthority(input, saved.currentJson);
-        if (allowReuse &&
-            saved.organizationId === input.organizationId &&
-            authorityReference !== undefined) {
-            const restored = await restorePrincipalPolicyHistoryVerifier(historyInput, saved.progress, await principalHistoryStageProtection(input.protection, head, saved));
-            if (restored.ok && (!saved.complete || restored.value.finish(head).ok)) {
-                await validatePublicHistoryAuthority(input, authorityReference);
-                return {
-                    id,
-                    scopeId,
-                    verifier: restored.value,
-                    completedHead: saved.complete ? head : null,
-                    afterVersion: saved.afterVersion,
-                    saved,
-                    cachedPrefix: null,
-                    authorityReference,
-                };
-            }
-        }
-        if (!input.offline)
-            await discardPrincipalHistoryStage(input.execSql, saved, current);
-    }
-    if (allowReuse) {
-        const prefix = await restorePublicPrefix(input, scopeId, id, await loadPrincipalHistoryPrefix(input.execSql, scopeId));
-        if (prefix)
-            return prefix;
-    }
-    return {
-        id,
-        scopeId,
-        verifier: createPrincipalPolicyHistoryVerifier(historyInput),
-        completedHead: null,
-        afterVersion: 0,
-        saved: null,
-        cachedPrefix: null,
-        authorityReference: null,
-    };
-}
-/** A resumed stage may finish after the reader that rejected the prefix exits. */
-async function rejectedCompletedPrefix(input, progress, history) {
-    const candidate = await loadPrincipalHistoryPrefix(input.execSql, progress.scopeId);
-    if (!candidate || candidate.version <= history.currentEntry.state.version)
-        return null;
-    try {
-        const cached = await restorePublicPrefix(input, progress.scopeId, progress.id, candidate);
-        if (!cached?.completedHead)
-            return null;
-        const finished = cached.verifier.finish(cached.completedHead);
-        if (!finished.ok)
-            throw finished.error;
-        const proof = await loadPrincipalHistoryReference({
-            execSql: input.execSql,
-            scopeId: progress.scopeId,
-            history: finished.value,
-            version: input.source.head.version,
-        });
-        const verified = await verifyPrincipalPolicyHistoryReferences({
-            history: finished.value,
-            references: [proof],
-        });
-        if (!verified.ok)
-            throw verified.error;
-        return principalHeadMatchesReference(proof.entry.state, input.source.head)
-            ? null
-            : candidate;
-    }
-    catch (error) {
-        if (error instanceof KeyingVerificationError ||
-            error instanceof PublicHistoryAuthorityUnavailableError)
-            return candidate;
-        throw error;
-    }
-}
-export async function publishPublicPrincipalHistoryPrefix(input, progress, history, rejectedPrefix) {
-    const state = history.currentEntry.state;
-    const head = {
-        principalType: state.principalType,
-        principalId: state.principalId,
-        version: state.version,
-        stateHash: state.stateHash,
-        keyEpoch: state.keyEpoch,
-        keyFingerprint: state.keyFingerprint,
-    };
-    const prefix = {
-        scopeId: progress.scopeId,
-        organizationId: input.organizationId,
-        version: head.version,
-        headJson: serializeKeyingCanonicalJson(head),
-        currentJson: publicHistoryAuthorityJson(progress.authorityReference),
-    };
-    const sealed = await progress.verifier.exportProgress(await principalHistoryPrefixProtection(input.protection, prefix));
-    if (!sealed.ok)
-        throw sealed.error;
-    const rejected = rejectedPrefix ??
-        (progress.cachedPrefix
-            ? null
-            : await rejectedCompletedPrefix(input, progress, history));
-    const stillCurrent = () => !input.signal?.aborted && input.stillCurrent();
-    await savePrincipalHistoryPrefix({
-        indexRootHash: history.indexRootHash,
-        execSql: input.execSql,
-        prefix: { ...prefix, progress: sealed.value },
-        stillCurrent,
-        rejectedPrefix: rejected,
-    });
-    if (progress.saved)
-        await discardPrincipalHistoryStage(input.execSql, progress.saved, stillCurrent);
-}
-//# sourceMappingURL=publicPrincipalHistoryProgress.js.map

package/workflows/principals/publicPrincipalHistoryProgress.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"publicPrincipalHistoryProgress.js","sourceRoot":"","sources":["publicPrincipalHistoryProgress.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  createPrincipalPolicyHistoryVerifier,\n  KeyingVerificationError,\n  restorePrincipalPolicyHistoryVerifier,\n  serializeKeyingCanonicalJson,\n  type VerifiedPrincipalPolicyHistory,\n  verifyPrincipalPolicyHistoryReferences,\n} from \"@tearleads/crypto\";\nimport { isReferencedPrincipalStateResponse } from \"@tearleads/validators/response\";\nimport { loadPrincipalHistoryReference } from \"../../data/persistence/principalHistoryEvidencePersistence\";\nimport {\n  discardPrincipalHistoryPrefix,\n  loadPrincipalHistoryPrefix,\n  type PrincipalHistoryPrefix,\n  savePrincipalHistoryPrefix,\n} from \"../../data/persistence/principalHistoryPrefixPersistence\";\nimport {\n  discardPrincipalHistoryStage,\n  loadPrincipalHistoryStage,\n} from \"../../data/persistence/principalHistoryStagePersistence\";\nimport { principalHeadMatchesReference } from \"../../data/principals/organizationAuthorityDescriptor\";\nimport {\n  principalHistoryEvidenceScopeId,\n  principalHistoryPrefixProtection,\n} from \"../../data/principals/principalHistoryPrefixProtection\";\nimport {\n  principalHistoryStageId,\n  principalHistoryStageProtection,\n} from \"../../data/principals/principalHistoryStageProtection\";\nimport {\n  PublicHistoryAuthorityUnavailableError,\n  parsePublicHistoryAuthority,\n  publicHistoryAuthorityJson,\n  validatePublicHistoryAuthority,\n} from \"./publicPrincipalHistoryAuthority\";\nimport type {\n  PublicPrincipalHistoryOptions,\n  PublicPrincipalHistoryProgress,\n} from \"./publicPrincipalHistoryTypes\";\n\nasync function restorePublicPrefix(\n  input: PublicPrincipalHistoryOptions,\n  scopeId: string,\n  id: string,\n  prefix: PrincipalHistoryPrefix | null,\n): Promise<PublicPrincipalHistoryProgress | null> {\n  const head = input.source.head;\n  const historyInput = {\n    principalType: head.principalType,\n    principalId: head.principalId,\n  };\n  const current = () => !input.signal?.aborted && input.stillCurrent();\n  if (prefix) {\n    const authorityReference = parsePublicHistoryAuthority(\n      input,\n      prefix.currentJson,\n    );\n    let prefixHead: unknown;\n    try {\n      prefixHead = JSON.parse(prefix.headJson);\n    } catch {\n      prefixHead = null;\n    }\n    if (\n      prefix.organizationId === input.organizationId &&\n      authorityReference !== undefined &&\n      isReferencedPrincipalStateResponse(prefixHead) &&\n      prefixHead.principalId === head.principalId &&\n      prefixHead.principalType === head.principalType &&\n      prefixHead.version === prefix.version\n    ) {\n      const restored = await restorePrincipalPolicyHistoryVerifier(\n        historyInput,\n        prefix.progress,\n        await principalHistoryPrefixProtection(input.protection, prefix),\n      );\n      if (restored.ok && restored.value.finish(prefixHead).ok) {\n        await validatePublicHistoryAuthority(input, authorityReference, prefix);\n        return {\n          id,\n          scopeId,\n          verifier: restored.value,\n          completedHead: prefixHead.version >= head.version ? prefixHead : null,\n          afterVersion: Math.min(prefixHead.version, head.version - 1),\n          saved: null,\n          cachedPrefix: prefix,\n          authorityReference,\n        };\n      }\n    }\n    if (!input.offline)\n      await discardPrincipalHistoryPrefix({\n        execSql: input.execSql,\n        prefix,\n        stillCurrent: current,\n      });\n  }\n  return null;\n}\n\nexport async function restorePublicPrincipalHistoryProgress(\n  input: PublicPrincipalHistoryOptions,\n  allowReuse: boolean,\n): Promise<PublicPrincipalHistoryProgress> {\n  const head = input.source.head;\n  const historyInput = {\n    principalType: head.principalType,\n    principalId: head.principalId,\n  };\n  const scopeId = await principalHistoryEvidenceScopeId({\n    organizationId: input.organizationId,\n    head,\n    protection: input.protection,\n  });\n  const id = await principalHistoryStageId(\n    input.organizationId,\n    head,\n    input.protection.context,\n  );\n  const current = () => !input.signal?.aborted && input.stillCurrent();\n  const saved = await loadPrincipalHistoryStage(input.execSql, id);\n  if (saved) {\n    const authorityReference = parsePublicHistoryAuthority(\n      input,\n      saved.currentJson,\n    );\n    if (\n      allowReuse &&\n      saved.organizationId === input.organizationId &&\n      authorityReference !== undefined\n    ) {\n      const restored = await restorePrincipalPolicyHistoryVerifier(\n        historyInput,\n        saved.progress,\n        await principalHistoryStageProtection(input.protection, head, saved),\n      );\n      if (restored.ok && (!saved.complete || restored.value.finish(head).ok)) {\n        await validatePublicHistoryAuthority(input, authorityReference);\n        return {\n          id,\n          scopeId,\n          verifier: restored.value,\n          completedHead: saved.complete ? head : null,\n          afterVersion: saved.afterVersion,\n          saved,\n          cachedPrefix: null,\n          authorityReference,\n        };\n      }\n    }\n    if (!input.offline)\n      await discardPrincipalHistoryStage(input.execSql, saved, current);\n  }\n  if (allowReuse) {\n    const prefix = await restorePublicPrefix(\n      input,\n      scopeId,\n      id,\n      await loadPrincipalHistoryPrefix(input.execSql, scopeId),\n    );\n    if (prefix) return prefix;\n  }\n  return {\n    id,\n    scopeId,\n    verifier: createPrincipalPolicyHistoryVerifier(historyInput),\n    completedHead: null,\n    afterVersion: 0,\n    saved: null,\n    cachedPrefix: null,\n    authorityReference: null,\n  };\n}\n\n/** A resumed stage may finish after the reader that rejected the prefix exits. */\nasync function rejectedCompletedPrefix(\n  input: PublicPrincipalHistoryOptions,\n  progress: PublicPrincipalHistoryProgress,\n  history: VerifiedPrincipalPolicyHistory,\n): Promise<PrincipalHistoryPrefix | null> {\n  const candidate = await loadPrincipalHistoryPrefix(\n    input.execSql,\n    progress.scopeId,\n  );\n  if (!candidate || candidate.version <= history.currentEntry.state.version)\n    return null;\n  try {\n    const cached = await restorePublicPrefix(\n      input,\n      progress.scopeId,\n      progress.id,\n      candidate,\n    );\n    if (!cached?.completedHead) return null;\n    const finished = cached.verifier.finish(cached.completedHead);\n    if (!finished.ok) throw finished.error;\n    const proof = await loadPrincipalHistoryReference({\n      execSql: input.execSql,\n      scopeId: progress.scopeId,\n      history: finished.value,\n      version: input.source.head.version,\n    });\n    const verified = await verifyPrincipalPolicyHistoryReferences({\n      history: finished.value,\n      references: [proof],\n    });\n    if (!verified.ok) throw verified.error;\n    return principalHeadMatchesReference(proof.entry.state, input.source.head)\n      ? null\n      : candidate;\n  } catch (error) {\n    if (\n      error instanceof KeyingVerificationError ||\n      error instanceof PublicHistoryAuthorityUnavailableError\n    )\n      return candidate;\n    throw error;\n  }\n}\n\nexport async function publishPublicPrincipalHistoryPrefix(\n  input: PublicPrincipalHistoryOptions,\n  progress: PublicPrincipalHistoryProgress,\n  history: VerifiedPrincipalPolicyHistory,\n  rejectedPrefix: PrincipalHistoryPrefix | null,\n): Promise<void> {\n  const state = history.currentEntry.state;\n  const head = {\n    principalType: state.principalType,\n    principalId: state.principalId,\n    version: state.version,\n    stateHash: state.stateHash,\n    keyEpoch: state.keyEpoch,\n    keyFingerprint: state.keyFingerprint,\n  };\n  const prefix = {\n    scopeId: progress.scopeId,\n    organizationId: input.organizationId,\n    version: head.version,\n    headJson: serializeKeyingCanonicalJson(head),\n    currentJson: publicHistoryAuthorityJson(progress.authorityReference),\n  };\n  const sealed = await progress.verifier.exportProgress(\n    await principalHistoryPrefixProtection(input.protection, prefix),\n  );\n  if (!sealed.ok) throw sealed.error;\n  const rejected =\n    rejectedPrefix ??\n    (progress.cachedPrefix\n      ? null\n      : await rejectedCompletedPrefix(input, progress, history));\n  const stillCurrent = () => !input.signal?.aborted && input.stillCurrent();\n  await savePrincipalHistoryPrefix({\n    indexRootHash: history.indexRootHash,\n    execSql: input.execSql,\n    prefix: { ...prefix, progress: sealed.value },\n    stillCurrent,\n    rejectedPrefix: rejected,\n  });\n  if (progress.saved)\n    await discardPrincipalHistoryStage(\n      input.execSql,\n      progress.saved,\n      stillCurrent,\n    );\n}\n"]}

package/workflows/principals/publicPrincipalHistoryTypes.d.ts

@@ -1,41 +0,0 @@
-import type { PrincipalPolicyExternalAuthority, PrincipalPolicyHistoryProgressOptions, PrincipalPolicyHistoryVerifier, ReferencedPrincipalHead, VerifiedPrincipalPolicyHistory } from "../../internal/crypto/index.js";
-import type { PrincipalPolicyHistorySourceResponse } from "../../internal/validators/response/index.js";
-import type { PrincipalHistoryPrefix } from "../../data/persistence/principalHistoryPrefixPersistence.js";
-import type { PrincipalHistoryStage } from "../../data/persistence/principalHistoryStagePersistence.js";
-import type { ExecSql } from "../../data/sqlite/sqlSchema.js";
-import type { TrustedUserIdentityResolver } from "../../data/trustedUserIdentity/index.js";
-import type { ProjectionPolicyHistoryReader } from "./principalPolicyHistoryReader.js";
-export interface PublicPrincipalHistoryOptions {
-    readonly historyReader: ProjectionPolicyHistoryReader;
-    /** Terminal proof verification defers durable currency until all artifacts authenticate. */
-    readonly historicalProof?: boolean | undefined;
-    readonly source: PrincipalPolicyHistorySourceResponse;
-    readonly organizationId: string;
-    readonly execSql: ExecSql;
-    readonly protection: PrincipalPolicyHistoryProgressOptions;
-    readonly resolveTrustedUserIdentity: TrustedUserIdentityResolver;
-    readonly stillCurrent: () => boolean;
-    readonly signal?: AbortSignal | undefined;
-    readonly offline?: boolean | undefined;
-    /** Retry disposable evidence loss once from signatures, without reusing hints. */
-    readonly replay?: boolean | undefined;
-    readonly strictAdmins?: boolean | undefined;
-    /** Already verified organization binding; included in the protected cache scope. */
-    readonly authorityGroupId?: string | undefined;
-    readonly loadExternalAuthority?: ((references: readonly ReferencedPrincipalHead[], cachedPrefix?: boolean) => Promise<PrincipalPolicyExternalAuthority | undefined>) | undefined;
-}
-export interface PublicPrincipalHistoryProgress {
-    readonly id: string;
-    readonly scopeId: string;
-    readonly verifier: PrincipalPolicyHistoryVerifier;
-    readonly completedHead: ReferencedPrincipalHead | null;
-    readonly afterVersion: number;
-    readonly saved: PrincipalHistoryStage | null;
-    readonly cachedPrefix: PrincipalHistoryPrefix | null;
-    readonly authorityReference: ReferencedPrincipalHead | null;
-}
-/** Public authorization only; caller must check directory binding and local pins. */
-export interface RecoveredPublicPrincipalHistory {
-    readonly scopeId: string;
-    readonly history: VerifiedPrincipalPolicyHistory;
-}

package/workflows/principals/publicPrincipalHistoryTypes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"publicPrincipalHistoryTypes.js","sourceRoot":"","sources":["publicPrincipalHistoryTypes.ts"],"names":[],"mappings":"","sourcesContent":["import type {\n  PrincipalPolicyExternalAuthority,\n  PrincipalPolicyHistoryProgressOptions,\n  PrincipalPolicyHistoryVerifier,\n  ReferencedPrincipalHead,\n  VerifiedPrincipalPolicyHistory,\n} from \"@tearleads/crypto\";\nimport type { PrincipalPolicyHistorySourceResponse } from \"@tearleads/validators/response\";\nimport type { PrincipalHistoryPrefix } from \"../../data/persistence/principalHistoryPrefixPersistence\";\nimport type { PrincipalHistoryStage } from \"../../data/persistence/principalHistoryStagePersistence\";\nimport type { ExecSql } from \"../../data/sqlite/sqlSchema\";\nimport type { TrustedUserIdentityResolver } from \"../../data/trustedUserIdentity\";\nimport type { ProjectionPolicyHistoryReader } from \"./principalPolicyHistoryReader\";\n\nexport interface PublicPrincipalHistoryOptions {\n  readonly historyReader: ProjectionPolicyHistoryReader;\n  /** Terminal proof verification defers durable currency until all artifacts authenticate. */\n  readonly historicalProof?: boolean | undefined;\n  readonly source: PrincipalPolicyHistorySourceResponse;\n  readonly organizationId: string;\n  readonly execSql: ExecSql;\n  readonly protection: PrincipalPolicyHistoryProgressOptions;\n  readonly resolveTrustedUserIdentity: TrustedUserIdentityResolver;\n  readonly stillCurrent: () => boolean;\n  readonly signal?: AbortSignal | undefined;\n  readonly offline?: boolean | undefined;\n  /** Retry disposable evidence loss once from signatures, without reusing hints. */\n  readonly replay?: boolean | undefined;\n  readonly strictAdmins?: boolean | undefined;\n  /** Already verified organization binding; included in the protected cache scope. */\n  readonly authorityGroupId?: string | undefined;\n  readonly loadExternalAuthority?:\n    | ((\n        references: readonly ReferencedPrincipalHead[],\n        cachedPrefix?: boolean,\n      ) => Promise<PrincipalPolicyExternalAuthority | undefined>)\n    | undefined;\n}\n\nexport interface PublicPrincipalHistoryProgress {\n  readonly id: string;\n  readonly scopeId: string;\n  readonly verifier: PrincipalPolicyHistoryVerifier;\n  readonly completedHead: ReferencedPrincipalHead | null;\n  readonly afterVersion: number;\n  readonly saved: PrincipalHistoryStage | null;\n  readonly cachedPrefix: PrincipalHistoryPrefix | null;\n  readonly authorityReference: ReferencedPrincipalHead | null;\n}\n\n/** Public authorization only; caller must check directory binding and local pins. */\nexport interface RecoveredPublicPrincipalHistory {\n  readonly scopeId: string;\n  readonly history: VerifiedPrincipalPolicyHistory;\n}\n"]}

package/workflows/principals/publicProjectionDirectory.js

@@ -1,40 +0,0 @@
-import { computePrincipalStatePayloadCiphertextHash, } from "../../internal/crypto/index.js";
-import { parseOrganizationAuthorityDescriptor, principalHeadMatchesReference, } from "../../data/principals/organizationAuthorityDescriptor.js";
-import { rejectPublicProjection, selectPublicProjectionPrincipal, } from "./publicProjectionPrincipal.js";
-export async function publicProjectionDirectoryBindings(evidence, organization) {
-    const policies = await selectPublicProjectionPrincipal(organization);
-    const entries = policies.flatMap((policy) => policy.retainedHistory);
-    const descriptors = [];
-    const seen = new Set();
-    for (const { reference, payload } of evidence.organizationPayloads) {
-        const state = entries.find(({ state }) => principalHeadMatchesReference(state, reference))?.state;
-        if (!state ||
-            reference.version > organization.options.source.head.version ||
-            payload.principalType !== "organization" ||
-            payload.principalId !== organization.options.organizationId ||
-            payload.stateHash !== state.stateHash ||
-            seen.has(state.stateHash))
-            rejectPublicProjection("directory payload scope is invalid");
-        seen.add(state.stateHash);
-        const hash = await computePrincipalStatePayloadCiphertextHash(payload.ciphertext);
-        if (hash !== payload.ciphertextHash || hash !== state.payloadCiphertextHash)
-            rejectPublicProjection("directory payload differs from its signed hash");
-        const descriptor = parseOrganizationAuthorityDescriptor(payload.ciphertext);
-        if (descriptor.organizationId !== organization.options.organizationId)
-            rejectPublicProjection("directory belongs to another organization");
-        descriptors.push(descriptor);
-    }
-    const bindings = new Map();
-    for (const source of evidence.groups) {
-        if (source.head.principalType !== "group" ||
-            bindings.has(source.head.principalId))
-            rejectPublicProjection("group sources have invalid or repeated scopes");
-        const directory = descriptors.find((candidate) => candidate.groupHeads.some((head) => principalHeadMatchesReference(head, source.head)));
-        const adminHead = directory?.groupHeads.find((head) => head.principalId === directory.adminGroupId);
-        if (!adminHead)
-            rejectPublicProjection("group source lacks its signed directory binding");
-        bindings.set(source.head.principalId, { adminHead });
-    }
-    return bindings;
-}
-//# sourceMappingURL=publicProjectionDirectory.js.map

package/workflows/principals/publicProjectionDirectory.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"publicProjectionDirectory.js","sourceRoot":"","sources":["publicProjectionDirectory.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  computePrincipalStatePayloadCiphertextHash,\n  type ReferencedPrincipalHead,\n} from \"@tearleads/crypto\";\nimport type { ProjectionPolicyEvidenceResponse } from \"@tearleads/validators/response\";\nimport {\n  parseOrganizationAuthorityDescriptor,\n  principalHeadMatchesReference,\n} from \"../../data/principals/organizationAuthorityDescriptor\";\nimport {\n  type PublicProjectionPrincipal,\n  rejectPublicProjection,\n  selectPublicProjectionPrincipal,\n} from \"./publicProjectionPrincipal\";\n\nexport async function publicProjectionDirectoryBindings(\n  evidence: ProjectionPolicyEvidenceResponse,\n  organization: PublicProjectionPrincipal,\n) {\n  const policies = await selectPublicProjectionPrincipal(organization);\n  const entries = policies.flatMap((policy) => policy.retainedHistory);\n  const descriptors = [];\n  const seen = new Set<string>();\n  for (const { reference, payload } of evidence.organizationPayloads) {\n    const state = entries.find(({ state }) =>\n      principalHeadMatchesReference(state, reference),\n    )?.state;\n    if (\n      !state ||\n      reference.version > organization.options.source.head.version ||\n      payload.principalType !== \"organization\" ||\n      payload.principalId !== organization.options.organizationId ||\n      payload.stateHash !== state.stateHash ||\n      seen.has(state.stateHash)\n    )\n      rejectPublicProjection(\"directory payload scope is invalid\");\n    seen.add(state.stateHash);\n    const hash = await computePrincipalStatePayloadCiphertextHash(\n      payload.ciphertext,\n    );\n    if (hash !== payload.ciphertextHash || hash !== state.payloadCiphertextHash)\n      rejectPublicProjection(\"directory payload differs from its signed hash\");\n    const descriptor = parseOrganizationAuthorityDescriptor(payload.ciphertext);\n    if (descriptor.organizationId !== organization.options.organizationId)\n      rejectPublicProjection(\"directory belongs to another organization\");\n    descriptors.push(descriptor);\n  }\n  const bindings = new Map<string, { adminHead: ReferencedPrincipalHead }>();\n  for (const source of evidence.groups) {\n    if (\n      source.head.principalType !== \"group\" ||\n      bindings.has(source.head.principalId)\n    )\n      rejectPublicProjection(\"group sources have invalid or repeated scopes\");\n    const directory = descriptors.find((candidate) =>\n      candidate.groupHeads.some((head) =>\n        principalHeadMatchesReference(head, source.head),\n      ),\n    );\n    const adminHead = directory?.groupHeads.find(\n      (head) => head.principalId === directory.adminGroupId,\n    );\n    if (!adminHead)\n      rejectPublicProjection(\"group source lacks its signed directory binding\");\n    bindings.set(source.head.principalId, { adminHead });\n  }\n  return bindings;\n}\n"]}

package/workflows/principals/publicProjectionPrincipal.js

@@ -1,54 +0,0 @@
-import { KeyingVerificationError, } from "../../internal/crypto/index.js";
-import { assertProjectionVerificationCurrent } from "../../data/keyingProjectionVerification/types.js";
-import { loadPrincipalPolicyCheckpoint } from "../../data/persistence/keyingCheckpointPersistence.js";
-import { PrincipalHistoryEvidenceUnavailableError } from "./principalHistoryRecoveryReferences.js";
-import { recoverPublicPrincipalHistory } from "./recoverPublicPrincipalHistory.js";
-import { selectPublicPrincipalHistory } from "./selectPublicPrincipalHistory.js";
-/** The source head and every citation remain bound independently of a newer prefix. */
-export async function selectPublicProjectionPrincipal(principal, references = principal.references) {
-    const { options } = principal;
-    const current = () => !options.signal?.aborted && options.stillCurrent();
-    assertProjectionVerificationCurrent(current);
-    const checkpoint = await loadPrincipalPolicyCheckpoint(options.execSql, options.source.head.principalType, options.source.head.principalId);
-    try {
-        return await selectPublicPrincipalHistory({
-            execSql: options.execSql,
-            recovered: principal.recovered,
-            references: [options.source.head, ...references],
-            checkpoint,
-            deferCheckpointCheck: options.historicalProof,
-            includeGenesis: options.source.head.principalType === "organization",
-            stillCurrent: current,
-        });
-    }
-    catch (error) {
-        if (!(error instanceof PrincipalHistoryEvidenceUnavailableError))
-            throw error;
-        if (options.offline || principal.replayed)
-            throw error.verificationError;
-        principal.replayed = true;
-        principal.recovered = await recoverPublicPrincipalHistory({
-            ...options,
-            replay: true,
-        });
-        return selectPublicProjectionPrincipal(principal, references);
-    }
-}
-export async function recoverPublicProjectionPrincipal(options, references) {
-    const selected = references.filter((head) => head.principalType === options.source.head.principalType &&
-        head.principalId === options.source.head.principalId);
-    if (selected.some((head) => head.version > options.source.head.version))
-        rejectPublicProjection("citation exceeds its supplied source head");
-    const principal = {
-        options,
-        references: structuredClone(selected),
-        recovered: await recoverPublicPrincipalHistory(options),
-        replayed: false,
-    };
-    await selectPublicProjectionPrincipal(principal);
-    return principal;
-}
-export function rejectPublicProjection(message) {
-    throw new KeyingVerificationError("object_mismatch", `Public projection history: ${message}`);
-}
-//# sourceMappingURL=publicProjectionPrincipal.js.map

package/workflows/principals/publicProjectionPrincipal.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"publicProjectionPrincipal.js","sourceRoot":"","sources":["publicProjectionPrincipal.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  KeyingVerificationError,\n  type ReferencedPrincipalHead,\n} from \"@tearleads/crypto\";\nimport { assertProjectionVerificationCurrent } from \"../../data/keyingProjectionVerification/types\";\nimport { loadPrincipalPolicyCheckpoint } from \"../../data/persistence/keyingCheckpointPersistence\";\nimport { PrincipalHistoryEvidenceUnavailableError } from \"./principalHistoryRecoveryReferences\";\nimport type {\n  PublicPrincipalHistoryOptions,\n  RecoveredPublicPrincipalHistory,\n} from \"./publicPrincipalHistoryTypes\";\nimport { recoverPublicPrincipalHistory } from \"./recoverPublicPrincipalHistory\";\nimport { selectPublicPrincipalHistory } from \"./selectPublicPrincipalHistory\";\n\nexport interface PublicProjectionPrincipal {\n  readonly options: PublicPrincipalHistoryOptions;\n  readonly references: readonly ReferencedPrincipalHead[];\n  recovered: RecoveredPublicPrincipalHistory;\n  replayed: boolean;\n}\n\n/** The source head and every citation remain bound independently of a newer prefix. */\nexport async function selectPublicProjectionPrincipal(\n  principal: PublicProjectionPrincipal,\n  references: readonly ReferencedPrincipalHead[] = principal.references,\n) {\n  const { options } = principal;\n  const current = () => !options.signal?.aborted && options.stillCurrent();\n  assertProjectionVerificationCurrent(current);\n  const checkpoint = await loadPrincipalPolicyCheckpoint(\n    options.execSql,\n    options.source.head.principalType,\n    options.source.head.principalId,\n  );\n  try {\n    return await selectPublicPrincipalHistory({\n      execSql: options.execSql,\n      recovered: principal.recovered,\n      references: [options.source.head, ...references],\n      checkpoint,\n      deferCheckpointCheck: options.historicalProof,\n      includeGenesis: options.source.head.principalType === \"organization\",\n      stillCurrent: current,\n    });\n  } catch (error) {\n    if (!(error instanceof PrincipalHistoryEvidenceUnavailableError))\n      throw error;\n    if (options.offline || principal.replayed) throw error.verificationError;\n    principal.replayed = true;\n    principal.recovered = await recoverPublicPrincipalHistory({\n      ...options,\n      replay: true,\n    });\n    return selectPublicProjectionPrincipal(principal, references);\n  }\n}\n\nexport async function recoverPublicProjectionPrincipal(\n  options: PublicPrincipalHistoryOptions,\n  references: readonly ReferencedPrincipalHead[],\n): Promise<PublicProjectionPrincipal> {\n  const selected = references.filter(\n    (head) =>\n      head.principalType === options.source.head.principalType &&\n      head.principalId === options.source.head.principalId,\n  );\n  if (selected.some((head) => head.version > options.source.head.version))\n    rejectPublicProjection(\"citation exceeds its supplied source head\");\n  const principal = {\n    options,\n    references: structuredClone(selected),\n    recovered: await recoverPublicPrincipalHistory(options),\n    replayed: false,\n  };\n  await selectPublicProjectionPrincipal(principal);\n  return principal;\n}\n\nexport function rejectPublicProjection(message: string): never {\n  throw new KeyingVerificationError(\n    \"object_mismatch\",\n    `Public projection history: ${message}`,\n  );\n}\n"]}

package/workflows/principals/reconcileAcknowledgedPrincipalCurrent.js

@@ -1,68 +0,0 @@
-import { KeyingVerificationError, verifyPrincipalPolicyCurrent, } from "../../internal/crypto/index.js";
-import { loadPrincipalPolicyCheckpoint } from "../../data/persistence/keyingCheckpointPersistence.js";
-import { loadPrincipalHistoryPrefix } from "../../data/persistence/principalHistoryPrefixPersistence.js";
-import { principalHeadMatchesReference } from "../../data/principals/organizationAuthorityDescriptor.js";
-import { restoreAcknowledgedPrincipalPrefix } from "./acknowledgedPrincipalPredecessor.js";
-import { PrincipalHistoryEvidenceUnavailableError, selectRecoveredPrincipalHistory, } from "./principalHistoryRecoveryReferences.js";
-import { principalHistoryVerificationContext } from "./principalHistoryRecoveryVerification.js";
-/** Only the receipt is proven; a newer local pin needs scoped history covering it. */
-function reconcileReceiptOnly(publication, observedPrefixProgress, checkpoint) {
-    // Other verified evidence, such as a document purge proof, can pin a newer
-    // head without advancing this scope's prefix. That is honest progress this
-    // receipt cannot prove membership in: retry after recovery, not a rollback.
-    // A genesis receipt has no predecessor, so any existing pin stays a conflict.
-    if (publication.predecessorStage &&
-        checkpoint &&
-        checkpoint.version > publication.policy.version)
-        throw new PrincipalHistoryEvidenceUnavailableError(new KeyingVerificationError("missing_dependency", "A newer local principal pin is not covered by scoped history"));
-    return {
-        ...publication,
-        preservePrefix: false,
-        observedPrefixProgress,
-        observedCheckpoint: checkpoint,
-        retainedPrefix: publication.prefix,
-        checkpointPolicy: publication.policy,
-    };
-}
-/** Prove an already observed successor contains this receipt before preserving it. */
-export async function reconcileAcknowledgedPrincipalCurrent(input, publication) {
-    const options = {
-        ...input,
-        protection: {
-            ...input.protection,
-            context: principalHistoryVerificationContext(input),
-        },
-    };
-    const checkpoint = await loadPrincipalPolicyCheckpoint(options.execSql, publication.policy.principalType, publication.policy.principalId);
-    const saved = await loadPrincipalHistoryPrefix(options.execSql, publication.prefix.scopeId);
-    const observedPrefixProgress = saved?.progress ?? null;
-    if (observedPrefixProgress === publication.previousPrefixProgress)
-        return reconcileReceiptOnly(publication, observedPrefixProgress, checkpoint);
-    const restored = await restoreAcknowledgedPrincipalPrefix(options, saved);
-    if (restored.previous.version < publication.policy.version) {
-        if (!principalHeadMatchesReference(restored.previous.state, options.expectedHead))
-            throw new KeyingVerificationError("stale_predecessor", "Acknowledgement does not extend the authenticated current prefix");
-        return reconcileReceiptOnly(publication, observedPrefixProgress, checkpoint);
-    }
-    const history = await selectRecoveredPrincipalHistory({
-        options: { ...options, retainedReferences: [publication.policy.state] },
-        scopeId: publication.prefix.scopeId,
-        history: restored.history,
-        checkpoint,
-    });
-    const policy = await verifyPrincipalPolicyCurrent({
-        current: restored.artifacts,
-        history,
-    });
-    if (!policy.ok)
-        throw policy.error;
-    return {
-        ...publication,
-        preservePrefix: true,
-        observedPrefixProgress,
-        observedCheckpoint: checkpoint,
-        retainedPrefix: restored.saved,
-        checkpointPolicy: policy.value,
-    };
-}
-//# sourceMappingURL=reconcileAcknowledgedPrincipalCurrent.js.map

package/workflows/principals/reconcileAcknowledgedPrincipalCurrent.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"reconcileAcknowledgedPrincipalCurrent.js","sourceRoot":"","sources":["reconcileAcknowledgedPrincipalCurrent.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  KeyingVerificationError,\n  type PrincipalPolicyCheckpoint,\n  verifyPrincipalPolicyCurrent,\n} from \"@tearleads/crypto\";\nimport { loadPrincipalPolicyCheckpoint } from \"../../data/persistence/keyingCheckpointPersistence\";\nimport type {\n  AcknowledgedPrincipalCurrentPublication,\n  ReconciledPrincipalCurrentPublication,\n} from \"../../data/persistence/principalCurrentAcknowledgementPersistence\";\nimport { loadPrincipalHistoryPrefix } from \"../../data/persistence/principalHistoryPrefixPersistence\";\nimport { principalHeadMatchesReference } from \"../../data/principals/organizationAuthorityDescriptor\";\nimport { restoreAcknowledgedPrincipalPrefix } from \"./acknowledgedPrincipalPredecessor\";\nimport {\n  PrincipalHistoryEvidenceUnavailableError,\n  selectRecoveredPrincipalHistory,\n} from \"./principalHistoryRecoveryReferences\";\nimport type { RecoverPrincipalPolicyHistoryOptions } from \"./principalHistoryRecoveryTypes\";\nimport { principalHistoryVerificationContext } from \"./principalHistoryRecoveryVerification\";\n\n/** Only the receipt is proven; a newer local pin needs scoped history covering it. */\nfunction reconcileReceiptOnly(\n  publication: AcknowledgedPrincipalCurrentPublication,\n  observedPrefixProgress: string | null,\n  checkpoint: PrincipalPolicyCheckpoint | null,\n): ReconciledPrincipalCurrentPublication {\n  // Other verified evidence, such as a document purge proof, can pin a newer\n  // head without advancing this scope's prefix. That is honest progress this\n  // receipt cannot prove membership in: retry after recovery, not a rollback.\n  // A genesis receipt has no predecessor, so any existing pin stays a conflict.\n  if (\n    publication.predecessorStage &&\n    checkpoint &&\n    checkpoint.version > publication.policy.version\n  )\n    throw new PrincipalHistoryEvidenceUnavailableError(\n      new KeyingVerificationError(\n        \"missing_dependency\",\n        \"A newer local principal pin is not covered by scoped history\",\n      ),\n    );\n  return {\n    ...publication,\n    preservePrefix: false,\n    observedPrefixProgress,\n    observedCheckpoint: checkpoint,\n    retainedPrefix: publication.prefix,\n    checkpointPolicy: publication.policy,\n  };\n}\n\n/** Prove an already observed successor contains this receipt before preserving it. */\nexport async function reconcileAcknowledgedPrincipalCurrent(\n  input: RecoverPrincipalPolicyHistoryOptions,\n  publication: AcknowledgedPrincipalCurrentPublication,\n): Promise<ReconciledPrincipalCurrentPublication> {\n  const options = {\n    ...input,\n    protection: {\n      ...input.protection,\n      context: principalHistoryVerificationContext(input),\n    },\n  };\n  const checkpoint = await loadPrincipalPolicyCheckpoint(\n    options.execSql,\n    publication.policy.principalType,\n    publication.policy.principalId,\n  );\n  const saved = await loadPrincipalHistoryPrefix(\n    options.execSql,\n    publication.prefix.scopeId,\n  );\n  const observedPrefixProgress = saved?.progress ?? null;\n  if (observedPrefixProgress === publication.previousPrefixProgress)\n    return reconcileReceiptOnly(\n      publication,\n      observedPrefixProgress,\n      checkpoint,\n    );\n  const restored = await restoreAcknowledgedPrincipalPrefix(options, saved);\n  if (restored.previous.version < publication.policy.version) {\n    if (\n      !principalHeadMatchesReference(\n        restored.previous.state,\n        options.expectedHead,\n      )\n    )\n      throw new KeyingVerificationError(\n        \"stale_predecessor\",\n        \"Acknowledgement does not extend the authenticated current prefix\",\n      );\n    return reconcileReceiptOnly(\n      publication,\n      observedPrefixProgress,\n      checkpoint,\n    );\n  }\n  const history = await selectRecoveredPrincipalHistory({\n    options: { ...options, retainedReferences: [publication.policy.state] },\n    scopeId: publication.prefix.scopeId,\n    history: restored.history,\n    checkpoint,\n  });\n  const policy = await verifyPrincipalPolicyCurrent({\n    current: restored.artifacts,\n    history,\n  });\n  if (!policy.ok) throw policy.error;\n  return {\n    ...publication,\n    preservePrefix: true,\n    observedPrefixProgress,\n    observedCheckpoint: checkpoint,\n    retainedPrefix: restored.saved,\n    checkpointPolicy: policy.value,\n  };\n}\n"]}

package/workflows/principals/recoverCurrentOrganizationPolicy.js

@@ -1,38 +0,0 @@
-import { assertProjectionVerificationCurrent } from "../../data/keyingProjectionVerification/types.js";
-import { ownPrincipalHistoryProtection } from "../../data/principals/principalHistoryProtection.js";
-import { createPrincipalRecoveryReader, } from "./principalRecoveryMemo.js";
-import { isPrincipalRecoveryOutage } from "./principalRecoveryOutage.js";
-/** Discover and verify current directory artifacts, including protected offline recovery. */
-export async function recoverCurrentOrganizationPolicy(options, memo) {
-    const input = {
-        ...options,
-        protection: ownPrincipalHistoryProtection(options.protection),
-    };
-    try {
-        let directory;
-        let reader = createPrincipalRecoveryReader(input, memo);
-        try {
-            directory = await reader.directory([]);
-        }
-        catch (error) {
-            assertProjectionVerificationCurrent(input.stillCurrent);
-            if (input.offline || !isPrincipalRecoveryOutage(error))
-                throw error;
-            reader = createPrincipalRecoveryReader({ ...input, offline: true }, memo);
-            directory = await reader.directory([]);
-        }
-        // A reused directory keeps its producer's lifetime to the point of use.
-        const stillCurrent = () => input.stillCurrent() && reader.stillCurrent();
-        assertProjectionVerificationCurrent(stillCurrent);
-        return {
-            current: directory.current,
-            policy: directory.policy,
-            dependencies: [],
-            stillCurrent,
-        };
-    }
-    finally {
-        input.protection.localKey.fill(0);
-    }
-}
-//# sourceMappingURL=recoverCurrentOrganizationPolicy.js.map

package/workflows/principals/recoverCurrentOrganizationPolicy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"recoverCurrentOrganizationPolicy.js","sourceRoot":"","sources":["recoverCurrentOrganizationPolicy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mCAAmC,EAAE,MAAM,+CAA+C,CAAC;AACpG,OAAO,EAAE,6BAA6B,EAAE,MAAM,kDAAkD,CAAC;AAKjG,OAAO,EACL,6BAA6B,GAE9B,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AAEtE,6FAA6F;AAC7F,MAAM,CAAC,KAAK,UAAU,gCAAgC,CACpD,OAAiC,EACjC,IAA4B;IAE5B,MAAM,KAAK,GAAG;QACZ,GAAG,OAAO;QACV,UAAU,EAAE,6BAA6B,CAAC,OAAO,CAAC,UAAU,CAAC;KAC9D,CAAC;IACF,IAAI,CAAC;QACH,IAAI,SAAmC,CAAC;QACxC,IAAI,MAAM,GAAG,6BAA6B,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QACxD,IAAI,CAAC;YACH,SAAS,GAAG,MAAM,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;QACzC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,mCAAmC,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;YACxD,IAAI,KAAK,CAAC,OAAO,IAAI,CAAC,yBAAyB,CAAC,KAAK,CAAC;gBAAE,MAAM,KAAK,CAAC;YACpE,MAAM,GAAG,6BAA6B,CAAC,EAAE,GAAG,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE,IAAI,CAAC,CAAC;YAC1E,SAAS,GAAG,MAAM,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;QACzC,CAAC;QACD,wEAAwE;QACxE,MAAM,YAAY,GAAG,GAAG,EAAE,CAAC,KAAK,CAAC,YAAY,EAAE,IAAI,MAAM,CAAC,YAAY,EAAE,CAAC;QACzE,mCAAmC,CAAC,YAAY,CAAC,CAAC;QAClD,OAAO;YACL,OAAO,EAAE,SAAS,CAAC,OAAO;YAC1B,MAAM,EAAE,SAAS,CAAC,MAAM;YACxB,YAAY,EAAE,EAAE;YAChB,YAAY;SACb,CAAC;IACJ,CAAC;YAAS,CAAC;QACT,KAAK,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACpC,CAAC;AACH,CAAC","sourcesContent":["import { assertProjectionVerificationCurrent } from \"../../data/keyingProjectionVerification/types\";\nimport { ownPrincipalHistoryProtection } from \"../../data/principals/principalHistoryProtection\";\nimport type {\n  PrincipalRecoveryContext,\n  RecoveredPolicyDirectory,\n} from \"./principalRecoveryDirectory\";\nimport {\n  createPrincipalRecoveryReader,\n  type PrincipalRecoveryMemo,\n} from \"./principalRecoveryMemo\";\nimport { isPrincipalRecoveryOutage } from \"./principalRecoveryOutage\";\n\n/** Discover and verify current directory artifacts, including protected offline recovery. */\nexport async function recoverCurrentOrganizationPolicy(\n  options: PrincipalRecoveryContext,\n  memo?: PrincipalRecoveryMemo,\n) {\n  const input = {\n    ...options,\n    protection: ownPrincipalHistoryProtection(options.protection),\n  };\n  try {\n    let directory: RecoveredPolicyDirectory;\n    let reader = createPrincipalRecoveryReader(input, memo);\n    try {\n      directory = await reader.directory([]);\n    } catch (error) {\n      assertProjectionVerificationCurrent(input.stillCurrent);\n      if (input.offline || !isPrincipalRecoveryOutage(error)) throw error;\n      reader = createPrincipalRecoveryReader({ ...input, offline: true }, memo);\n      directory = await reader.directory([]);\n    }\n    // A reused directory keeps its producer's lifetime to the point of use.\n    const stillCurrent = () => input.stillCurrent() && reader.stillCurrent();\n    assertProjectionVerificationCurrent(stillCurrent);\n    return {\n      current: directory.current,\n      policy: directory.policy,\n      dependencies: [],\n      stillCurrent,\n    };\n  } finally {\n    input.protection.localKey.fill(0);\n  }\n}\n"]}

package/workflows/principals/recoverPrincipalHistoryPage.js

@@ -1,31 +0,0 @@
-import { KeyingVerificationError } from "../../internal/crypto/index.js";
-import { PRINCIPAL_DISPLAY_HISTORY_PAGE_SIZE } from "../../internal/validators/response/index.js";
-import { loadRecoveredPrincipalHistoryPage } from "./loadRecoveredPrincipalHistoryPage.js";
-import { PrincipalHistoryEvidenceUnavailableError } from "./principalHistoryRecoveryReferences.js";
-import { recoverPrincipalPolicyHistoryWithVersions } from "./recoverPrincipalPolicyHistory.js";
-/** Disposable page proof loss may replay signed pages once online, preserving durable pins. */
-export async function recoverPrincipalHistoryPage(options, beforeVersion) {
-    try {
-        return await loadRecoveredPrincipalHistoryPage(options, beforeVersion);
-    }
-    catch (error) {
-        if (!(error instanceof PrincipalHistoryEvidenceUnavailableError))
-            throw error;
-        // A local-first display read must distinguish disposable proof damage
-        // from a durable fork or an invalid caller citation, which are not wrapped.
-        // Preserve that distinction so the online caller can replay signed pages.
-        if (options.offline)
-            throw new KeyingVerificationError("missing_dependency", "Principal history display proof is unavailable");
-    }
-    const first = Math.max(1, beforeVersion - PRINCIPAL_DISPLAY_HISTORY_PAGE_SIZE - 1);
-    await recoverPrincipalPolicyHistoryWithVersions(options, Array.from({ length: beforeVersion - first }, (_, index) => first + index));
-    try {
-        return await loadRecoveredPrincipalHistoryPage(options, beforeVersion);
-    }
-    catch (error) {
-        throw error instanceof PrincipalHistoryEvidenceUnavailableError
-            ? error.verificationError
-            : error;
-    }
-}
-//# sourceMappingURL=recoverPrincipalHistoryPage.js.map