@tinycloud/share-sdk 1.2.0-beta.3 → 1.2.0-beta.4

package/dist/share-index.d.ts

@@ -0,0 +1,1063 @@
+import { a as SenderShareRecordStorage, S as SenderShareRecord } from './history-CyT6x8h4.js';
+export { f as SenderShareRecordProofs } from './history-CyT6x8h4.js';
+import { j as PublishedShareDeliveryMaterial, q as SignedDelegation, g as OwnerSharePolicyRegistration } from './owner-policy-BqzRlkb6.js';
+import { ShareEnvelopeV3 } from '@tinycloud/share-envelope';
+
+/**
+ * Identifiers and the key classifier for the shared share index
+ * (TC-1432 design C §1). All keys here are relative to the vault prefix
+ * `sender-history/v2/records/`.
+ */
+/** Vault key prefix of every share record and of the index documents. */
+declare const SHARE_RECORDS_VAULT_PREFIX = "sender-history/v2/records/";
+/** The main index document key. */
+declare const INDEX_MAIN_KEY = "_index/main";
+/** Length of a DID-derived agent id (132 bits of base64url). */
+declare const AGENT_ID_LENGTH = 22;
+/** `^[A-Za-z0-9_-]{1,512}$`, excluding the reserved first segments `_index` and `agents`. */
+declare function isShareId(value: unknown): value is string;
+declare function isAgentId(value: unknown): value is string;
+/**
+ * The first 22 base64url characters of
+ * `sha256("xyz.tinycloud.share/agent-id/v1|" + agentDid)`. `agentDid` is the
+ * DID of the key that signs the agent's invocations and delegations, so a new
+ * key gets a new prefix.
+ */
+declare function agentIdFromDid(agentDid: string): string;
+declare function agentRecordKey(agentId: string, shareId: string): string;
+/** Explicit list prefix (with the trailing slash) of one agent's records, relative to `records/`. */
+declare function agentRecordPrefix(agentId: string): string;
+type ClassifiedRecordKey = {
+    readonly kind: "index";
+    readonly name: string;
+} | {
+    readonly kind: "web";
+    readonly shareId: string;
+} | {
+    readonly kind: "agent";
+    readonly agentId: string;
+    readonly shareId: string;
+}
+/**
+ * Never fetched, never rendered. `agentId`/`suffix` are set when the key
+ * lies inside an agent prefix (`agents/<valid id>/…`), so it is counted
+ * once against that agent; any other key can only be written by owner
+ * clients and is skipped without counting.
+ */
+ | {
+    readonly kind: "rejected";
+    readonly agentId?: string;
+    readonly suffix?: string;
+};
+/**
+ * Classify one raw listed key (relative to `records/`), before any
+ * needs-attention logic. A key containing `%`, `\`, a `.`/`..` segment, an
+ * empty segment or a leading `/` is rejected first.
+ */
+declare function classifyRecordKey(key: string): ClassifiedRecordKey;
+
+/**
+ * Share link validator (design C §5 check 6, §6 Open/Copy). A link is
+ * accepted only when it is https on a configured share origin and has one of
+ * the share link shapes:
+ * - `/s/<cid>#k=<key>`: registry envelope link;
+ * - `/s/inline#v=2&p=<payload>`: Node Policy/v3 sealed-inline link (what
+ *   `publishAddressedShare` emits);
+ * - `/viewer#tc1=<token>`: native bearer link (`createNativeShare`).
+ *
+ * The result names the shape only; the link itself is never copied into it.
+ */
+type ShareLinkShape = "envelope" | "inline" | "native";
+type ShareLinkCheck = {
+    readonly ok: true;
+    readonly shape: ShareLinkShape;
+} | {
+    readonly ok: false;
+};
+declare function validateShareLink(link: unknown, shareOrigins: readonly string[]): ShareLinkCheck;
+
+/**
+ * The agent's key-encryption key (design C §3, V3-6). Security-sensitive:
+ * keep this module small and free of logging.
+ *
+ *   KEK_a = HKDF-SHA256(ikm = private key bytes,
+ *                       salt = "xyz.tinycloud.share/agent-kek/v1",
+ *                       info = agentDid)
+ *   kid   = HKDF-SHA256(same ikm and salt, info = "kid")[0..8]
+ *
+ * The private key is the one the agent signs its invocations and delegations
+ * with (the session key when it has a private part, otherwise the profile
+ * key), and `agentDid` is that key's DID. KEK_a is imported non-extractable,
+ * for AES-GCM wrapping only.
+ */
+interface AgentKeyMaterial {
+    readonly agentDid: string;
+    /** base64url of the first 8 bytes of HKDF(…, info "kid"). */
+    readonly kid: string;
+    readonly kek: CryptoKey;
+}
+/**
+ * Derive KEK_a and kid. `privateKeyBytes` is read, never retained; the caller
+ * owns (and should zero) it.
+ */
+declare function deriveAgentKeyMaterial(privateKeyBytes: Uint8Array, agentDid: string): Promise<AgentKeyMaterial>;
+
+/**
+ * Agent record codec: the double-wrapped data key (design C §3, R1, V3-3..6).
+ * Security-sensitive: keep this module small; nothing here logs, and no
+ * error carries key bytes.
+ *
+ * One stored value per record, `vault/…/records/agents/<agentId>/<shareId>`:
+ *
+ *   { hdr: { v: 1, agentDid, kid, alg: "A256GCM", ownerNetworkId, recordV },
+ *     ct:        b64url(iv ‖ AES-256-GCM(encKey, record, aad = B)),
+ *     commit:    b64url(HMAC-SHA256(commitKey, B)),
+ *     wrapAgent: b64url(iv ‖ AES-256-GCM(KEK_a, DEK, aad = B)) | null,
+ *     wrapOwner: owner-network envelope of DEK with aad = B }
+ *
+ *   B         = "xyz.tinycloud.share/agent-record/v1|" + spaceId + "|" + vaultKey
+ *               + "|" + agentDid + "|" + ownerNetworkId   (EVM addresses lowercased)
+ *   encKey    = HKDF-SHA256(DEK, info "enc|" + B)
+ *   commitKey = HKDF-SHA256(DEK, info "commit|" + B)
+ *
+ * Every seal takes a fresh random 32-byte DEK and fresh random 96-bit nonces.
+ * The DEK itself is never used as a key. Opening requires the unwrapped DEK
+ * to be exactly 32 bytes, checks `commit` in constant time, and zeroes the
+ * DEK on every path.
+ */
+declare const AGENT_RECORD_VERSION = 1;
+/** Record schema versions this build understands. */
+declare const SUPPORTED_AGENT_RECORD_V = 1;
+/**
+ * Stored agent records larger than this are refused before any crypto.
+ * Design C proposed 16 KiB (open decision 1); a real CLI bearer record that
+ * carries its link and its full chain (C1: link UCAN + owner→session CACAO)
+ * measured 16,918 B on a local node, so the cap is 32 KiB.
+ */
+declare const MAX_AGENT_RECORD_BYTES: number;
+type AgentRecordFailure = "size" | "shape" | "header" | "newer" | "decrypt" | "commit";
+/** A refused agent record. The message is fixed per reason. */
+declare class AgentRecordError extends Error {
+    readonly reason: AgentRecordFailure;
+    constructor(reason: AgentRecordFailure);
+}
+/** Thrown by an {@link OwnerNetworkUnwrap} when the decrypt service is unreachable (not a refusal). */
+declare class OwnerUnwrapUnavailableError extends Error {
+    constructor();
+}
+interface AgentRecordHeader {
+    readonly v: 1;
+    readonly agentDid: string;
+    readonly kid: string | null;
+    readonly alg: "A256GCM";
+    readonly ownerNetworkId: string;
+    readonly recordV: number;
+}
+interface StoredAgentRecord {
+    readonly hdr: AgentRecordHeader;
+    readonly ct: string;
+    readonly commit: string;
+    readonly wrapAgent: string | null;
+    readonly wrapOwner: Readonly<Record<string, unknown>>;
+}
+/** Encrypts the DEK to the owner network (needs no capability). */
+interface OwnerNetworkWrap {
+    wrap(dek: Uint8Array, aad: Uint8Array): Promise<Readonly<Record<string, unknown>>>;
+}
+/**
+ * Network-decrypts the owner wrap. Implementations must pass `aad` to the
+ * decrypt call so the envelope's declared AAD is compared before any POST.
+ */
+interface OwnerNetworkUnwrap {
+    unwrap(envelope: Readonly<Record<string, unknown>>, aad: Uint8Array): Promise<Uint8Array>;
+}
+interface AgentRecordBindingInput {
+    readonly spaceId: string;
+    /** Full vault key: `sender-history/v2/records/agents/<agentId>/<shareId>`. */
+    readonly vaultKey: string;
+    readonly agentDid: string;
+    readonly ownerNetworkId: string;
+}
+declare function agentRecordBinding(input: AgentRecordBindingInput): Uint8Array;
+interface SealAgentRecordInput extends AgentRecordBindingInput {
+    /** UTF-8 JSON of the full `SenderShareRecord` (link and `proofs` included). */
+    readonly plaintext: Uint8Array;
+    /** Absent for a remote-signer-only profile: the record is then owner-readable only (`kid: null`). */
+    readonly agentKey?: AgentKeyMaterial;
+    readonly ownerWrap: OwnerNetworkWrap;
+    readonly recordV?: number;
+}
+/** Seal one agent record. Each call draws a fresh DEK and fresh nonces. */
+declare function sealAgentRecord(input: SealAgentRecordInput): Promise<StoredAgentRecord>;
+/**
+ * Parse the stored bytes and check the header against the path (§5 checks
+ * 2–3), before any crypto. `newer` means a higher `recordV` than this build
+ * knows: skip and re-check after an upgrade, do not reject.
+ */
+declare function parseStoredAgentRecord(bytes: Uint8Array, expected: {
+    readonly agentDid?: string;
+    readonly ownerNetworkId: string;
+}): StoredAgentRecord;
+/**
+ * Owner path (§3 steps 2–4): refuse locally, before any network call, an
+ * owner wrap whose declared AAD is not exactly B or whose network is not the
+ * owner's; then network-unwrap, and open.
+ */
+declare function openAgentRecordAsOwner(record: StoredAgentRecord, location: {
+    readonly spaceId: string;
+    readonly vaultKey: string;
+}, unwrap: OwnerNetworkUnwrap): Promise<Uint8Array>;
+/** Agent read-back: `wrapAgent` under KEK_a; no owner-network decrypt anywhere. */
+declare function openAgentRecordAsAgent(record: StoredAgentRecord, location: {
+    readonly spaceId: string;
+    readonly vaultKey: string;
+}, agentKey: AgentKeyMaterial): Promise<Uint8Array>;
+
+/**
+ * Storage port of the share index (design C §1, §4). Every key is relative to
+ * `sender-history/v2/records/`. The port is structural so share-sdk does not
+ * depend on the TinyCloud SDK packages; {@link createTinyCloudShareIndexBackend}
+ * adapts a TinyCloud client (node or web SDK) to it.
+ */
+type ShareDocumentRead = {
+    readonly status: "ok";
+    readonly value: unknown;
+    readonly etag: string;
+} | {
+    readonly status: "not_found";
+}
+/** Deterministic corruption (bad envelope, AAD bound elsewhere, undecodable payload). */
+ | {
+    readonly status: "corrupt";
+    readonly etag?: string;
+}
+/** Outage or transient failure: never a reason to rebuild. */
+ | {
+    readonly status: "unavailable";
+};
+type ShareRawRead = {
+    readonly status: "ok";
+    readonly bytes: Uint8Array;
+    readonly etag: string;
+} | {
+    readonly status: "not_found";
+}
+/** Larger than the `maxBytes` the caller passed: the node refused to send the body, or its length was over. */
+ | {
+    readonly status: "too_large";
+} | {
+    readonly status: "unavailable";
+};
+type ShareWriteCondition = {
+    readonly ifMatch: string;
+} | {
+    readonly ifNoneMatch: "*";
+};
+type ShareWriteResult = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly code: "conflict" | "outcome_unknown" | "busy" | "unauthorized" | "failed";
+}
+/** The etag was refused as malformed (for example weakened to `W/"…"` in transit). Never retried; `message` is the SDK's own. */
+ | {
+    readonly ok: false;
+    readonly code: "invalid_etag";
+    readonly message: string;
+};
+type ShareListResult = {
+    readonly status: "ok";
+    readonly keys: readonly string[];
+    readonly cursor?: string;
+} | {
+    readonly status: "unavailable";
+};
+interface ShareIndexBackend {
+    readonly spaceId: string;
+    readonly ownerNetworkId: string;
+    /** Owner-network vault read with the slice-1 AAD check, from the network (never a replica). */
+    readVault(key: string): Promise<ShareDocumentRead>;
+    /** Owner-network vault write: a fresh envelope each time; conditional when `condition` is set. */
+    writeVault(key: string, value: unknown, condition?: ShareWriteCondition): Promise<ShareWriteResult>;
+    /** Delete a record; an absent key counts as success. */
+    deleteRecord(key: string): Promise<ShareWriteResult>;
+    /** One page of keys under `prefix` (relative, with its trailing slash, or "" for all records). */
+    listKeys(prefix: string, cursor?: string): Promise<ShareListResult>;
+    /**
+     * Raw stored bytes and etag (agent records), from the network. With
+     * `maxBytes`, a larger value is reported `too_large` and its body is not
+     * downloaded (see {@link createTinyCloudShareIndexBackend}).
+     */
+    readRaw(key: string, maxBytes?: number): Promise<ShareRawRead>;
+    writeRaw(key: string, value: Readonly<Record<string, unknown>>, condition: ShareWriteCondition): Promise<ShareWriteResult>;
+    readonly ownerWrap: OwnerNetworkWrap;
+    /** Owner-network decrypt; absent for Tier W agents, which have no decrypt grant. */
+    readonly ownerUnwrap?: OwnerNetworkUnwrap;
+}
+/** The vault's classified network read (`readNetworkEncrypted`), as this adapter consumes it. */
+interface VaultNetworkRead {
+    readonly status: string;
+    readonly entry?: {
+        readonly value: unknown;
+        readonly etag?: string;
+    };
+}
+type SdkResult<T> = {
+    readonly ok: true;
+    readonly data: T;
+} | {
+    readonly ok: false;
+    readonly error: {
+        readonly code: string;
+        readonly message?: string;
+        readonly meta?: Record<string, unknown>;
+    };
+};
+/** The subset of a TinyCloud client the adapter uses (node-sdk `TinyCloudNode` or the web SDK). */
+interface TinyCloudShareIndexClient {
+    readonly vault: {
+        readNetworkEncrypted(key: string, options: {
+            readonly expectAad: true;
+        }): Promise<VaultNetworkRead>;
+        put(key: string, value: unknown, options?: {
+            readonly ifMatch?: string;
+            readonly ifNoneMatch?: "*";
+        }): Promise<SdkResult<unknown>>;
+        delete(key: string): Promise<SdkResult<unknown>>;
+    };
+    readonly kv: {
+        /** `maxResponseBytes`: the node refuses (413, `KV_RESPONSE_TOO_LARGE`) a larger value before sending its body. */
+        get(key: string, options: {
+            readonly prefix: "";
+            readonly raw: true;
+            readonly source: "network";
+            readonly maxResponseBytes?: number;
+        }): Promise<SdkResult<{
+            readonly data: unknown;
+            readonly headers: {
+                readonly etag?: string;
+            };
+        }>>;
+        put(key: string, value: unknown, options: {
+            readonly prefix: "";
+            readonly ifMatch?: string;
+            readonly ifNoneMatch?: "*";
+        }): Promise<SdkResult<unknown>>;
+        list(options: {
+            readonly prefix: string;
+            readonly removePrefix: true;
+            readonly limit: number;
+            readonly cursor?: string;
+            readonly source: "network";
+        }): Promise<SdkResult<{
+            readonly keys: readonly string[];
+            readonly nextCursor?: string;
+            readonly truncated?: boolean;
+        }>>;
+    };
+    readonly encryption: {
+        encryptToNetwork(networkId: string, plaintext: Uint8Array, options: {
+            readonly aad: Uint8Array;
+        }): Promise<SdkResult<object>>;
+        decryptEnvelope?(envelope: never, proof: {
+            readonly proofs: readonly string[];
+        }, options: {
+            readonly aad: Uint8Array;
+        }): Promise<SdkResult<Uint8Array>>;
+    };
+}
+/** Shown when the SDK reports `INVALID_ETAG` without a message of its own. */
+declare const INVALID_ETAG_MESSAGE = "etag was weakened in transit; compare-and-swap unavailable through this path";
+interface TinyCloudShareIndexBackendOptions {
+    readonly client: TinyCloudShareIndexClient;
+    readonly spaceId: string;
+    readonly ownerNetworkId: string;
+    /** The decrypt capability proof of the owner session (`{ proofs: [session.delegationCid] }`). Omit for Tier W agents. */
+    readonly decryptProof?: () => {
+        readonly proofs: readonly string[];
+    };
+    /**
+     * The KV prefix every key here sits under: `vault/sender-history/v2/records/`
+     * for a client whose KV service has no prefix of its own.
+     */
+    readonly kvRecordsPrefix?: string;
+}
+/** Adapt a TinyCloud client (owner web, owner-key CLI, Tier 2 or Tier W agent) to {@link ShareIndexBackend}. */
+declare function createTinyCloudShareIndexBackend(options: TinyCloudShareIndexBackendOptions): ShareIndexBackend;
+
+/**
+ * The compare-and-swap loop policy shared by the index and the record stores
+ * (design C §4, plus the lead's rule for slice 2):
+ * - every attempt starts with a fresh network read and re-applies the change,
+ *   so a lost race (`ETAG_MISMATCH`) and an unknown outcome (`OUTCOME_UNKNOWN`)
+ *   are both decided from what the node now holds, never by a blind re-put;
+ * - `ETAG_MISMATCH` and `NODE_BUSY` back off 50 ms·2ⁿ with jitter, capped at
+ *   1 s, for at most 6 attempts;
+ * - `INVALID_ETAG` is never retried: the first one throws
+ *   {@link ShareIndexCasError} with the SDK's own message (an ETag weakened
+ *   in transit, for example by a CDN, cannot be used for compare-and-swap).
+ */
+interface CasPolicy {
+    readonly maxAttempts: number;
+    readonly backoffBaseMs: number;
+    readonly backoffCapMs: number;
+    readonly sleep: (ms: number) => Promise<void>;
+    readonly random: () => number;
+}
+declare const DEFAULT_CAS_POLICY: CasPolicy;
+type ShareIndexCasErrorCode = 
+/** The etag was refused as malformed; compare-and-swap is unavailable through this path. Never retried. */
+"INVALID_ETAG"
+/** Every attempt lost a race or found the node busy. */
+ | "EXHAUSTED"
+/** The write was refused (authorization, storage) or the read failed. */
+ | "FAILED";
+declare class ShareIndexCasError extends Error {
+    readonly code: ShareIndexCasErrorCode;
+    readonly key: string;
+    readonly attempts: number;
+    constructor(code: ShareIndexCasErrorCode, message: string, key: string, attempts: number);
+}
+
+declare class WebShareRecordStore implements SenderShareRecordStorage {
+    private readonly backend;
+    private readonly cas;
+    constructor(backend: ShareIndexBackend, cas?: CasPolicy);
+    put(record: SenderShareRecord): Promise<void>;
+    update(shareId: string, change: (record: SenderShareRecord) => SenderShareRecord | Promise<SenderShareRecord>): Promise<SenderShareRecord | undefined>;
+    get(shareId: string): Promise<SenderShareRecord | undefined>;
+    list(): Promise<readonly SenderShareRecord[]>;
+    delete(shareId: string): Promise<void>;
+}
+interface AgentShareRecordStoreOptions {
+    readonly backend: ShareIndexBackend;
+    /** DID of the key that signs the agent's invocations and delegations. */
+    readonly agentDid: string;
+    /** KEK_a from the same key; absent for a remote-signer-only profile (records are then owner-readable only). */
+    readonly agentKey?: AgentKeyMaterial;
+    readonly cas?: CasPolicy;
+    /**
+     * The share origin on which records read back get their Policy/v3
+     * `/s/inline` link rebuilt (the stored form keeps no link; see
+     * `delivery.ts`). Absent: records read back carry no v3 link.
+     */
+    readonly shareOrigin?: string;
+}
+declare class AgentShareRecordStore implements SenderShareRecordStorage {
+    private readonly options;
+    readonly agentId: string;
+    private readonly cas;
+    constructor(options: AgentShareRecordStoreOptions);
+    /** Whether this profile can read its own records back (`kid` is set). */
+    get canReadBack(): boolean;
+    private location;
+    private seal;
+    private open;
+    /** Create or replace; each write is a fresh seal under CAS (If-None-Match `*` for a new key). */
+    put(record: SenderShareRecord): Promise<void>;
+    /** CAS update with the etag from the agent's own read (for example its own `revokedAt`). */
+    update(shareId: string, change: (record: SenderShareRecord) => SenderShareRecord | Promise<SenderShareRecord>): Promise<SenderShareRecord | undefined>;
+    get(shareId: string): Promise<SenderShareRecord | undefined>;
+    /** Lists the explicit `agents/<agentId>/` prefix (trailing slash: `list({})` would be refused). */
+    list(): Promise<readonly SenderShareRecord[]>;
+    /** Tier W has no delete grant on its prefix; the owner deletes agent records. */
+    delete(_shareId: string): Promise<void>;
+}
+
+/**
+ * The stored form of a share record in the space (TC-1432 slice 2, cap
+ * ruling): each blob is stored once.
+ *
+ * A Policy/v3 record's `deliveryMaterial.envelope` is exactly what
+ * `sealedEnvelope` decrypts to under `envelopeKey` (`publishAddressedShare`
+ * seals `canonicalize(envelope)`), and its `/s/inline` link is
+ * `sealedEnvelope`, its CID and `envelopeKey` encoded again. Both are
+ * dropped before an agent record is sealed and rebuilt when needed:
+ * {@link openDeliveryEnvelope} for the verifier and a delivery retry,
+ * {@link shareLinkForRecord} at Open/Copy. `sealedEnvelope` stays (the node
+ * reopens that exact value and its nonce is random) and so does the session
+ * CACAO (it proves the chain). A bearer record keeps its `link`, which is
+ * not derivable.
+ *
+ * Security-sensitive: the sealed bytes are checked against `shareCid` before
+ * they are opened, and the plaintext must be the canonical JSON of the
+ * envelope, so a record cannot carry one envelope for display and another for
+ * the node.
+ */
+type StoredDeliveryMaterial = Omit<PublishedShareDeliveryMaterial, "envelope">;
+/** A share record as stored at an agent (or migrated) key: {@link SenderShareRecord} without derivable blobs. */
+type StoredShareRecord = Omit<SenderShareRecord, "deliveryMaterial"> & {
+    readonly deliveryMaterial?: StoredDeliveryMaterial;
+};
+/** Keys of a stored `deliveryMaterial`, exactly. */
+declare const STORED_DELIVERY_MATERIAL_KEYS: readonly string[];
+declare class DeliveryMaterialError extends Error {
+    constructor(message: string);
+}
+/** The signed envelope inside `sealedEnvelope`; throws {@link DeliveryMaterialError} unless it is exactly that. */
+declare function openDeliveryEnvelope(material: StoredDeliveryMaterial): Promise<Record<string, unknown>>;
+/**
+ * The link to show at Open/Copy: a bearer record's stored `link`, or a
+ * Policy/v3 record's `/s/inline` link rebuilt on `shareOrigin` (the
+ * viewer's configured share origin) from `sealedEnvelope` and `envelopeKey`.
+ */
+declare function shareLinkForRecord(record: Pick<StoredShareRecord, "link" | "deliveryMaterial">, shareOrigin: string): Promise<string | undefined>;
+/**
+ * The stored form of `record`. For a Policy/v3 record (one with
+ * `deliveryMaterial`), drops `deliveryMaterial.envelope` and `link` after
+ * checking they are exactly what the sealed material rebuilds, so nothing is
+ * lost. Throws {@link DeliveryMaterialError} otherwise.
+ */
+declare function compactShareRecord(record: SenderShareRecord | StoredShareRecord): Promise<StoredShareRecord>;
+/**
+ * The full record again (for a delivery retry or a caller that wants the
+ * {@link SenderShareRecord} shape): the envelope reopened from the sealed
+ * material and, when `shareOrigin` is given, the `/s/inline` link rebuilt.
+ */
+declare function expandShareRecord(record: StoredShareRecord, shareOrigin?: string): Promise<SenderShareRecord>;
+
+/**
+ * Index document schema v1, rows, `project()`, and the versioned agent-record
+ * schema (design C §2, §5 check 5). The index holds display fields only:
+ * never `link`, `deliveryMaterial`, share keys, unmasked emails or `#k=`.
+ * Unknown fields on the header, on agent entries and on rows are kept.
+ */
+declare const INDEX_SCHEMA_VERSION = 1;
+type ShareProofState = "proven" | "chained" | "unproven";
+interface ShareIndexRow {
+    /** Display name: ≤120 characters, bidi and control characters stripped. */
+    readonly n: string;
+    readonly k: "file" | "folder";
+    /** Content kind: the lowercase file extension, when there is a short one. */
+    readonly ck?: string;
+    readonly ak: "bearer" | "recipientDid" | "exactEmail" | "emailDomain";
+    /** Masked audience label. */
+    readonly al: string;
+    readonly a: readonly string[];
+    /** Created (`registeredAt`) and expires, ISO 8601. */
+    readonly c: string;
+    readonly x: string;
+    /** Revocation; only `confirmed` (node-confirmed) is sticky. */
+    readonly r?: {
+        readonly at: string;
+        readonly confirmed: boolean;
+    };
+    /**
+     * Revoke kind. For agent rows the revoke action is decided at click time
+     * from the freshly verified record (§6). Observed on a local node (C5,
+     * TC-1432 slice 2):
+     * - per share: the owner wallet can revoke an agent's v3 root (`policyRoot`,
+     *   `enforcementRoot` CIDs from the signed envelope) through the generic
+     *   `/revoke` route: 200, and an open recipient session's next read gets 403
+     *   `root-revoked`. Only the JSON root-revocation route answers 403
+     *   `root-revocation-issuer-invalid` to the owner.
+     * - session-wide: revoking the agent's owner→session delegation kills its
+     *   bearer links and fails new v3 claims at once, but an already-open v3
+     *   recipient session keeps reading for its lifetime (3,598 s observed).
+     *   The node liveness check (N3, test B-1) closes that.
+     */
+    readonly rk: "policy-v3" | "delegation" | "none";
+    /** The share's revoke CID; unique across rows. */
+    readonly cid?: string;
+    /** Every CID this row claims (one row per CID, §5 check 7). */
+    readonly cc?: readonly string[];
+    /** Provenance, derived from the key path: `web` or `agent:<agentId>`. */
+    readonly src: string;
+    /** Agent and migrated rows: the proof state of the verified chain. */
+    readonly ps?: ShareProofState;
+    /** `migrated`: a one-time owner import (shown as "imported"); ranks by `ps`, never as a web row. */
+    readonly pv?: "migrated";
+    /** The verified chain has expired (shown as Expired, not rejected). */
+    readonly pe?: true;
+    /** Needs attention: unreadable record, or `shareId` ≠ key basename. */
+    readonly na?: true;
+    readonly [unknown: string]: unknown;
+}
+interface ShareIndexAgentEntry {
+    /** The agent DID, once a record with a valid header was seen. */
+    readonly did: string | null;
+    readonly rows: number;
+    readonly rejected: Readonly<Record<string, number>>;
+    /** Raw key suffixes (≤64 chars) refused on first sight: never refetched. At most 100. */
+    readonly rejectedKeys: readonly string[];
+    /** Keys whose `recordV` is newer than this build: skipped until an upgrade. At most 100. */
+    readonly newerKeys?: readonly string[];
+    readonly newerV?: number;
+    readonly paused: false | {
+        readonly reason: "rejections" | "row-cap" | "newer";
+        readonly at: string;
+    };
+    readonly firstSeen: string;
+    readonly [unknown: string]: unknown;
+}
+interface ShareIndexDocument {
+    readonly v: number;
+    readonly ownerDid: string;
+    readonly spaceId: string;
+    readonly updatedAt: string;
+    readonly updatedBy: string;
+    readonly archives: readonly {
+        readonly name: string;
+        readonly ids: readonly string[];
+    }[];
+    readonly tombstones: readonly {
+        readonly key: string;
+        readonly at: string;
+    }[];
+    readonly reconcile: {
+        readonly cursor?: string;
+    };
+    readonly agents: Readonly<Record<string, ShareIndexAgentEntry>>;
+    readonly rows: Readonly<Record<string, ShareIndexRow>>;
+    readonly [unknown: string]: unknown;
+}
+interface ShareIndexArchiveDocument {
+    readonly v: number;
+    readonly rows: Readonly<Record<string, ShareIndexRow>>;
+    readonly [unknown: string]: unknown;
+}
+type ParsedIndexDocument = {
+    readonly status: "ok";
+    readonly doc: ShareIndexDocument;
+}
+/** A higher `v`: render read-only, never write. */
+ | {
+    readonly status: "newer";
+    readonly v: number;
+}
+/** Decrypted, but not a valid document: deterministic corruption. */
+ | {
+    readonly status: "invalid";
+};
+declare function parseIndexDocument(value: unknown): ParsedIndexDocument;
+/** Strip bidi/control/format characters and cap at 120 code points. */
+declare function displayName(value: unknown, fallback: string): string;
+/**
+ * The display-only projection of a record. `claims` overrides the CIDs the
+ * row may claim (agent rows claim only what their chain verified).
+ */
+declare function project(record: StoredShareRecord, input: {
+    readonly key: string;
+    readonly src: string;
+    readonly claims?: readonly string[];
+    readonly proof?: {
+        readonly state: ShareProofState;
+        readonly expired: boolean;
+    };
+}): ShareIndexRow;
+/**
+ * Whether `spaceId` (`tinycloud:pkh:eip155:<chain>:<address>:<name>`) is a
+ * space of the account `ownerDid` (`did:pkh:eip155:<chain>:<address>`),
+ * whatever its name: the CLI keeps share content in `default` while the
+ * records live in `applications`. Address spelling is ignored.
+ */
+declare function isSpaceOwnedBy(spaceId: string, ownerDid: string): boolean;
+/** A record refused by the schema. `provenance`: an agent-subtree record claiming `migrated`. */
+declare class ShareRecordSchemaError extends Error {
+    readonly reason: "schema" | "provenance";
+    constructor(reason: "schema" | "provenance");
+}
+
+declare function claimRank(row: Pick<ShareIndexRow, "src" | "ps" | "pv">): number;
+type ClaimDecision = {
+    readonly admit: true;
+    readonly displaced: readonly string[];
+} | {
+    readonly admit: false;
+    readonly heldBy: string;
+};
+/**
+ * Decide a new claim `row` at `key` against the rows already in `rows`.
+ * Collisions are rows (other than `key` itself) that claim any CID in common.
+ * Web rows never displace other web rows (both are owner-written).
+ */
+declare function decideClaim(rows: Readonly<Record<string, ShareIndexRow>>, key: string, row: ShareIndexRow): ClaimDecision;
+
+/**
+ * Attenuation containment (design C4): every (resource, ability) of the child
+ * must be granted by the parent on the same resource or on a parent resource
+ * under the segment-prefix rule `child == parent || child.startsWith(parent
+ * + "/")` (a parent already ending in `/` is a prefix itself), as
+ * `unified.ts:1225-1233` applies it. EVM address spelling is ignored. A
+ * parent ability whose caveats are all empty objects is unrestricted;
+ * otherwise the child's caveats must be identical. Fail-closed.
+ */
+type Attenuation = Readonly<Record<string, Readonly<Record<string, readonly unknown[]>>>>;
+declare function attenuationCovers(parent: Attenuation, child: Attenuation): boolean;
+
+/**
+ * Owner→session SIWE CACAO checks (design C4). Security-sensitive.
+ *
+ * Signature, canonical DAG-CBOR, exact-bytes CID and the ReCap statement are
+ * verified by the injected parser: sdk-core `parseSignedSiweCacao`
+ * (`cacao.ts:205-276`; share-sdk cannot depend on sdk-core, which depends on
+ * share-sdk). That parser does not check validity times, so this module adds:
+ * `Not Before`/`Expiration Time` against `now`, issuer == the account owner,
+ * audience == the child's issuer, and child attenuation ⊆ the CACAO's. `Not
+ * Before` and `Issued At` are read from the verified bytes ({@link cacaoTimes}).
+ */
+interface ParsedSiweCacao {
+    readonly cid: string;
+    /** `did:pkh:eip155:<chain>:<address>`. */
+    readonly issuer: string;
+    /** SIWE `uri`: the delegate DID. */
+    readonly audience: string;
+    readonly attenuation: Attenuation;
+    readonly expiresAt?: string;
+}
+/** Verifies signature, encoding and the exact-bytes CID; throws otherwise. */
+type SiweCacaoParser = (authorization: string, expectedCid: string) => Promise<ParsedSiweCacao>;
+type DelegationTime = "current" | "expired";
+interface OwnerSessionCheck {
+    readonly authorization: string;
+    readonly expectedCid: string;
+    readonly accountOwnerDid: string;
+    /** The issuer of the delegation this CACAO must authorize (the leaf or root issuer). */
+    readonly childIssuer: string;
+    readonly childAttenuation: Attenuation;
+    readonly now: Date;
+    readonly parse: SiweCacaoParser;
+}
+interface VerifiedOwnerSession {
+    readonly cid: string;
+    /** The session principal (audience without fragment). */
+    readonly sessionDid: string;
+    readonly time: DelegationTime;
+    /** The signed `Issued At` (epoch ms), when the parser reports it. */
+    readonly issuedAt?: number;
+}
+/** Throws when the CACAO does not prove the owner→session hop; reports expiry separately. */
+declare function verifyOwnerSessionDelegation(input: OwnerSessionCheck): Promise<VerifiedOwnerSession>;
+
+/**
+ * CID ownership by proof (design C §5 check 7, C1–C4). Everything is checked
+ * from the signed bytes the record carries; nothing is fetched.
+ *
+ * - `proven`: the full chain verifies to the account owner and the leaf
+ *   issuer (the policy owner for Policy/v3) is `hdr.agentDid`.
+ * - `chained`: the full chain verifies to the account owner through another key.
+ * - `unproven`: the leaf verifies but the owner→session CACAO is absent.
+ * - `expired` is reported next to the state: a chain that verifies but has
+ *   expired is admitted as Expired, not rejected.
+ * - anything else: `{ ok: false }` (reason `proof`).
+ *
+ * Supported chains: native bearer links (`proofs.link` + `proofs.session`),
+ * Policy/v3 addressed shares (the envelope opened from
+ * `deliveryMaterial.sealedEnvelope`, bound to `shareCid`, + `proofs.session`)
+ * and Policy/v2 owner-policy shares (`proofs.ownerPolicy`, `ownerDelegation`,
+ * `enforcementDelegation`, optional `registration`).
+ *
+ * What revocation achieves today (local node, C5): the owner wallet's generic
+ * `/revoke` of a verified v3 root CID ends that share at once, open recipient
+ * sessions included (403 `root-revoked`); only the JSON root-revocation route
+ * refuses the owner (403 `root-revocation-issuer-invalid`). Revoking the
+ * verified session CACAO kills the session's bearer links and new v3 claims
+ * at once, but an already-open v3 recipient session keeps reading for its
+ * lifetime (3,598 s observed) until the node liveness check (N3, test B-1).
+ * Migrated records are verified with no agent binding, so they are never
+ * `proven`.
+ */
+type ChainVerdict = {
+    readonly ok: true;
+    readonly state: ShareProofState;
+    readonly expired: boolean;
+    readonly claims: readonly string[];
+    /**
+     * Where `registeredAt` may lie, from signed times in the chain (epoch ms):
+     * a signed issuance time ± {@link REGISTERED_AT_SKEW_MS} when the chain
+     * has one (link `nbf`, the v3 binding's `issuedAt`, the node's v2
+     * `registeredAt`); otherwise the session's signed `Issued At` as the
+     * earliest and the leaf's expiry as the latest.
+     */
+    readonly issued: {
+        readonly earliest?: number;
+        readonly latest?: number;
+    };
+} | {
+    readonly ok: false;
+    readonly detail: string;
+};
+/** The node registration key for a node audience, from the share public config. */
+interface ShareRegistrationKey {
+    readonly kid: string;
+    /** Raw 32-byte Ed25519 key, or its 34-byte did:key multicodec form. */
+    readonly publicKey: Uint8Array;
+}
+interface ChainContext {
+    readonly accountOwnerDid: string;
+    /** `hdr.agentDid`, already bound to the path by `derive(agentDid) == agentId`. */
+    readonly agentDid: string;
+    readonly now: Date;
+    readonly parseSiweCacao: SiweCacaoParser;
+    /** Registration key by `target.nodeAudience`; absent ⇒ `registrationCid` is not claimed. */
+    readonly registrationKey?: (nodeAudience: string) => ShareRegistrationKey | undefined;
+}
+/** Verify the chain behind every CID a stored agent (or migrated) record claims. Never throws. */
+declare function verifyAgentRecordChain(record: StoredShareRecord, context: ChainContext): Promise<ChainVerdict>;
+
+/**
+ * Signed UCAN verifier for issued delegations (native bearer link
+ * delegations and Policy/v3 owner roots). Security-sensitive.
+ *
+ * Same acceptance as sdk-core `parseSignedCompactUcanAttenuation`
+ * (`unified.ts:1281-1314`): EdDSA/JWT/ucv 0.10.0 header whose JWK binds the
+ * did:key issuer, strict Ed25519 signature, CID = CIDv1(raw, blake3) of the
+ * exact Authorization bytes. It additionally returns the verified `prf`,
+ * `nbf` and `exp` (design C4), and requires `exp`: an expiry-less delegation
+ * is refused. Payload JSON need not be JCS: WASM-issued link delegations are
+ * not.
+ */
+interface SignedUcanDelegation {
+    readonly cid: string;
+    /** Issuer principal without any `#fragment`. */
+    readonly issuer: string;
+    /** Audience principal without any `#fragment`. */
+    readonly audience: string;
+    readonly attenuation: Readonly<Record<string, Readonly<Record<string, readonly unknown[]>>>>;
+    readonly proofs: readonly string[];
+    readonly notBefore?: number;
+    readonly expiresAt: number;
+    readonly facts?: readonly unknown[];
+}
+declare function parseSignedUcan(authorization: string, expectedCid?: string): SignedUcanDelegation;
+
+/**
+ * Verifier for a Policy/v2 enforcement delegation
+ * (`TinyCloudSharePolicyEnforcement`, signed by the share key;
+ * `createPolicyEnforcementDelegation`). No verifier existed before
+ * (design C §5 check 7, C4).
+ *
+ * Checks, all fail-closed:
+ * - the DAG-CBOR bytes are exactly the canonical encoding of
+ *   `{ domain, unsigned: { type, version: 2, issuerDid, audienceDid, facts } }`
+ *   built from the delegation's own fields (so every reported field is signed);
+ * - the Ed25519 signature over those bytes verifies against `issuerDid`
+ *   (a did:key), strict RFC 8032;
+ * - the CID recomputed from the exact bytes equals `cid` (and `expectedCid`);
+ * - `facts.shareKeyDid` equals the issuer.
+ */
+declare function verifyPolicyEnforcementDelegation(delegation: SignedDelegation, expectedCid?: string): Promise<SignedDelegation>;
+
+/**
+ * `SenderShareIndex`: the encrypted, display-only share index at
+ * `records/_index/main` (design C §2, §4, §5, §7). Records stay canonical;
+ * the index is a projection that is only ever written with compare-and-swap.
+ */
+interface ShareIndexLimits {
+    readonly listPagesPerPass: number;
+    readonly fetchesPerPass: number;
+    readonly newRowsPerAgentPerPass: number;
+    readonly liveRowsPerAgent: number;
+    readonly rejectionsBeforePause: number;
+    /** Agent rows together may use at most this share of `mainRowBytes`. */
+    readonly agentRowShare: number;
+    readonly mainRowBytes: number;
+    readonly headerBytes: number;
+    readonly maxAgentRecordBytes: number;
+    readonly tombstoneTtlMs: number;
+    readonly archiveAgeMs: number;
+    readonly statusChecksPerSync: number;
+}
+declare const DEFAULT_SHARE_INDEX_LIMITS: ShareIndexLimits;
+/** Outbox ops carry rows and CIDs, never records. */
+type ShareIndexOp = {
+    readonly id: string;
+    readonly type: "upsert";
+    readonly key: string;
+    readonly row: ShareIndexRow;
+} | {
+    readonly id: string;
+    readonly type: "revoke";
+    readonly key: string;
+    readonly at: string;
+    readonly confirmed: boolean;
+}
+/** Only for revoked, expired or unreadable rows: tombstone first, then the caller deletes the record. */
+ | {
+    readonly id: string;
+    readonly type: "delete";
+    readonly key: string;
+}
+/** Owner agent controls: `resume` clears a pause; `recheck` also clears the agent's rejected lists. */
+ | {
+    readonly id: string;
+    readonly type: "agent";
+    readonly agentId: string;
+    readonly action: "resume" | "recheck";
+};
+/** Durable op queue: IndexedDB on the web, the profile cache for Tier 2. */
+interface ShareIndexOutbox {
+    list(): Promise<readonly ShareIndexOp[]>;
+    put(op: ShareIndexOp): Promise<void>;
+    remove(ids: readonly string[]): Promise<void>;
+}
+declare class MemoryShareIndexOutbox implements ShareIndexOutbox {
+    private readonly ops;
+    list(): Promise<readonly ShareIndexOp[]>;
+    put(op: ShareIndexOp): Promise<void>;
+    remove(ids: readonly string[]): Promise<void>;
+}
+/** Node-side status of a row's share, for status sync. `unknown` (e.g. agent-issued CIDs, TC-1419) changes nothing. */
+interface ShareStatusPort {
+    status(key: string, row: ShareIndexRow): Promise<"revoked" | "active" | "unknown">;
+}
+interface SenderShareIndexOptions {
+    readonly backend: ShareIndexBackend;
+    readonly outbox: ShareIndexOutbox;
+    /** The account owner (`did:pkh:…`). */
+    readonly ownerDid: string;
+    /** `updatedBy` label of this writer. */
+    readonly writer: string;
+    /** Configured share origins, for the link check. */
+    readonly shareOrigins: readonly string[];
+    /** sdk-core `parseSignedSiweCacao`. */
+    readonly parseSiweCacao: SiweCacaoParser;
+    /** Node registration keys by `nodeAudience`, from the share public config. */
+    readonly registrationKey?: (nodeAudience: string) => ShareRegistrationKey | undefined;
+    readonly limits?: Partial<ShareIndexLimits>;
+    readonly cas?: Partial<CasPolicy>;
+    readonly now?: () => Date;
+}
+type ShareIndexLoad = {
+    readonly status: "ok";
+    readonly doc: ShareIndexDocument;
+}
+/** A higher schema version: render read-only (option A path), never write. */
+ | {
+    readonly status: "read_only";
+    readonly v: number;
+} | {
+    readonly status: "not_found";
+}
+/** Deterministic corruption: the next write rebuilds. */
+ | {
+    readonly status: "corrupt";
+}
+/** Outage: never a reason to rebuild. */
+ | {
+    readonly status: "unavailable";
+};
+type ShareIndexWriteStatus = "written" | "unchanged" | "read_only" | "unavailable";
+interface ShareIndexWriteOutcome {
+    readonly status: ShareIndexWriteStatus;
+    /** The document as written, or as found when the change was already present. */
+    readonly doc?: ShareIndexDocument;
+}
+interface ShareIndexFlushResult {
+    readonly status: ShareIndexWriteStatus | "empty";
+    /** Op ids that can never apply (tombstoned upsert, delete of a live row, unknown row). They are dropped. */
+    readonly refused: readonly string[];
+}
+/**
+ * §5 rejection reasons; every check-4 failure (unwrap, DEK length, commit, GCM) is `decrypt`.
+ * `provenance`: an agent-subtree record claiming `migrated`, which only owner imports may carry.
+ */
+type AgentRejectReason = "size" | "shape" | "header" | "decrypt" | "schema" | "provenance" | "link" | "proof";
+interface ShareIndexReconcileReport {
+    readonly status: ShareIndexWriteStatus;
+    readonly pages: number;
+    readonly fetches: number;
+    readonly admitted: number;
+    readonly rejected: Readonly<Record<string, number>>;
+    readonly deferred: number;
+    /** True when this pass reached the end of the key listing. */
+    readonly cycleComplete: boolean;
+    /** The header reached its cap: new agent header state (entries, rejections) was not added. Show an alert; no row was evicted. */
+    readonly headerFull: boolean;
+}
+/** Encoded size of everything except the rows. */
+declare function headerBytes(doc: ShareIndexDocument): number;
+declare class SenderShareIndex {
+    private readonly options;
+    private readonly backend;
+    private readonly limits;
+    private readonly cas;
+    private readonly now;
+    constructor(options: SenderShareIndexOptions);
+    /** Library open: one GET + one decrypt. */
+    load(): Promise<ShareIndexLoad>;
+    enqueue(op: ShareIndexOp): Promise<void>;
+    /** Rebuild base after deterministic corruption: an empty document plus the archives found under `_index/`. */
+    private rebuildBase;
+    private emptyDoc;
+    /**
+     * Read → mutate → If-Match write, per {@link runCas}. A no-op change is never
+     * written. The header cap is enforced by the reconciler on agent-derived
+     * state only (see {@link reconcile}); the owner's own writes are never blocked by it.
+     */
+    private update;
+    /** When false (header at its cap), no new agent header state is added: no new entries, rejections or newer keys. */
+    private growHeader;
+    private ensureAgent;
+    /** Count a rejection once per key: a key already in `rejectedKeys` changes nothing. */
+    private recordRejection;
+    /** Remove a displaced row; a displaced agent claim counts as `proof` and is not refetched. */
+    private displace;
+    private isRetired;
+    private applyOp;
+    private displaceForDelete;
+    /**
+     * Apply every pending outbox op in one CAS. Ops leave the outbox only after
+     * the write is confirmed (or the change was already present). Any CAS error,
+     * including `INVALID_ETAG`, propagates with the ops still pending.
+     */
+    flush(): Promise<ShareIndexFlushResult>;
+    private examineAgentRecord;
+    /** §5 checks 5–7 for a decrypted record, shared by agent records and one-time owner imports. */
+    private checkRecord;
+    private peekRecordV;
+    private archivedClaims;
+    /**
+     * One budgeted pass: list keys from `reconcile.cursor`, fetch and check what
+     * the index does not know, then apply the findings in one CAS. Never
+     * deletes rows; tombstoned, archived and rejected keys are never refetched.
+     */
+    reconcile(): Promise<ShareIndexReconcileReport>;
+    private applyFindings;
+    syncStatus(port: ShareStatusPort): Promise<{
+        readonly status: ShareIndexWriteStatus;
+        readonly checked: number;
+    }>;
+    compact(): Promise<{
+        readonly status: ShareIndexWriteStatus;
+        readonly archived: number;
+    }>;
+}
+
+/**
+ * Policy/v2 node registration receipt, with expiry reported apart from
+ * invalidity (design C4). Security-sensitive.
+ *
+ * The package's `validateOwnerSharePolicyRegistration` refuses an expired
+ * receipt before checking anything else, so an expired-but-genuine receipt
+ * cannot be told from a forged one. This verifier makes the same checks
+ * (exact shape; binding to the chain's CIDs; every field the original compares
+ * against the canonical policy and the enforcement facts; canonical times;
+ * the CID over the canonical core; the node's Ed25519 signature against the
+ * registration key from the share public config) and then reports `expired`
+ * separately. `registrationCid` is not inside the node-signed core, so the
+ * CID-over-core check is what binds it.
+ */
+interface RegistrationKey {
+    readonly kid: string;
+    /** Raw 32-byte Ed25519 key, or its 34-byte did:key multicodec form. */
+    readonly publicKey: Uint8Array;
+}
+interface CheckedRegistration {
+    readonly status: "valid" | "expired";
+    readonly registration: OwnerSharePolicyRegistration;
+}
+/** Throws when the receipt does not verify; reports a verified receipt past its `expiresAt` as `expired`. */
+declare function checkRegistrationReceipt(value: unknown, expected: {
+    readonly policyCid: string;
+    readonly ownerDelegationCid: string;
+    readonly enforcementDelegationCid: string;
+    /** The `policy` object of the canonical Policy/v2 envelope whose bytes hash to `policyCid`. */
+    readonly policy: Readonly<Record<string, unknown>>;
+    /** The verified enforcement delegation's facts. */
+    readonly enforcementFacts: Readonly<Record<string, unknown>>;
+}, key: RegistrationKey, now: Date): CheckedRegistration;
+
+declare function verifyEnvelopeV3At(envelope: ShareEnvelopeV3, expectedSignerDid: string, now: number): Promise<boolean>;
+
+export { AGENT_ID_LENGTH, AGENT_RECORD_VERSION, type AgentKeyMaterial, AgentRecordError, type AgentRecordFailure, type AgentRecordHeader, type AgentRejectReason, AgentShareRecordStore, type AgentShareRecordStoreOptions, type Attenuation, type CasPolicy, type ChainContext, type ChainVerdict, type CheckedRegistration, type ClaimDecision, type ClassifiedRecordKey, DEFAULT_CAS_POLICY, DEFAULT_SHARE_INDEX_LIMITS, DeliveryMaterialError, INDEX_MAIN_KEY, INDEX_SCHEMA_VERSION, INVALID_ETAG_MESSAGE, MAX_AGENT_RECORD_BYTES, MemoryShareIndexOutbox, type OwnerNetworkUnwrap, type OwnerNetworkWrap, OwnerUnwrapUnavailableError, type ParsedSiweCacao, type RegistrationKey, SHARE_RECORDS_VAULT_PREFIX, STORED_DELIVERY_MATERIAL_KEYS, SUPPORTED_AGENT_RECORD_V, SenderShareIndex, type SenderShareIndexOptions, SenderShareRecord, type ShareDocumentRead, type ShareIndexAgentEntry, type ShareIndexArchiveDocument, type ShareIndexBackend, ShareIndexCasError, type ShareIndexCasErrorCode, type ShareIndexDocument, type ShareIndexFlushResult, type ShareIndexLimits, type ShareIndexLoad, type ShareIndexOp, type ShareIndexOutbox, type ShareIndexReconcileReport, type ShareIndexRow, type ShareIndexWriteOutcome, type ShareIndexWriteStatus, type ShareLinkCheck, type ShareLinkShape, type ShareListResult, type ShareProofState, type ShareRawRead, ShareRecordSchemaError, type ShareRegistrationKey, type ShareStatusPort, type ShareWriteCondition, type ShareWriteResult, type SignedUcanDelegation, type SiweCacaoParser, type StoredAgentRecord, type StoredDeliveryMaterial, type StoredShareRecord, type TinyCloudShareIndexBackendOptions, type TinyCloudShareIndexClient, type VaultNetworkRead, WebShareRecordStore, agentIdFromDid, agentRecordBinding, agentRecordKey, agentRecordPrefix, attenuationCovers, checkRegistrationReceipt, claimRank, classifyRecordKey, compactShareRecord, createTinyCloudShareIndexBackend, decideClaim, deriveAgentKeyMaterial, displayName, expandShareRecord, headerBytes, isAgentId, isShareId, isSpaceOwnedBy, openAgentRecordAsAgent, openAgentRecordAsOwner, openDeliveryEnvelope, parseIndexDocument, parseSignedUcan, parseStoredAgentRecord, project, sealAgentRecord, shareLinkForRecord, validateShareLink, verifyAgentRecordChain, verifyEnvelopeV3At, verifyOwnerSessionDelegation, verifyPolicyEnforcementDelegation };