@the_library/public 1.0.0 → 2.0.1

package/dist/{session-vqOnyxga.d.ts → session-JudUKAV7.d.ts}

@@ -1,75 +1,5 @@
-import { S as SidecarType, I as InstanceData, L as Lang, a as SidecarUrls, Q as QueueItem, u as uid, O as Orm } from './orm-BvkX0aBT.js';
-
-/**
- * Sidecar binary wire format — parser and writer (SPEC §4).
- *
- * Every sidecar file begins with a 10-byte header (all multi-byte integers
- * are big-endian):
- *
- *   Offset  Size  Field
- *   0       4     Magic number: 0x44504D31 ("DPM1")
- *   4       1     Format version (0x02)
- *   5       3     recordCount (uint24, big-endian, max 16,777,215)
- *   8       1     columnCount (uint8)
- *   9       1     sidecarType (0x00 = Slim, 0x01 = Extended, 0x02 = Provenance)
- *
- * Format version 0x01 used a uint16 recordCount (2 bytes, max 65,535) and
- * uint16 relation target UIDs. Version 0x02 expands both to uint24.
- *
- * Columns follow sequentially: columnType (u8), nameLen (u8), name (UTF-8),
- * then the column data block. Extended sidecars carry two structured tail
- * sections after the columns: relations (self-describing) and instances.
- */
-
-/** Column type codes (SPEC §4.1). */
-declare enum ColumnType {
-    Uint8 = 1,
-    Uint16 = 2,
-    NullableString = 3,
-    Relation = 4,// structured tail — flat uint32 stream
-    InstanceArray = 5,// structured tail — self-describing instance section
-    Uint32 = 6,
-    Bool = 7
-}
-/**
- * One entry of the instance field descriptor embedded in Extended sidecars.
- *
- * The instances tail is SELF-DESCRIBING: the writer embeds
- * `fieldCount + (typeCode, name)*` once per file, and instances are encoded
- * in descriptor order. The parser never consults any model schema, so:
- *   - old files keep parsing correctly after instanceFields change,
- *   - any model with `multipleInstances: true` works with zero new code,
- *   - files written under an older schema simply yield InstanceData objects
- *     missing the newer fields.
- */
-interface InstanceFieldSpec {
-    name: string;
-    type: ColumnType;
-}
-type ColumnData = Uint8Array | Uint16Array | Uint32Array | Array<string | null>;
-interface SidecarHeader {
-    formatVersion: number;
-    recordCount: number;
-    columnCount: number;
-    sidecarType: SidecarType;
-}
-interface ParsedSidecar {
-    header: SidecarHeader;
-    columns: Map<string, ColumnData>;
-    /**
-     * Per-record target-UID arrays for every `has`-direction relation, keyed by
-     * the schema relation name (Extended sidecars only). Self-describing: the
-     * writer embeds the relation names in the file, so the parser needs no
-     * schema and new relations parse with zero code change.
-     */
-    relations?: Map<string, number[][]>;
-    /** Back-compat alias for `relations.get('authors')`. */
-    authorIds?: number[][];
-    /** Field descriptor the instances were encoded with (Extended only). */
-    instanceFields?: InstanceFieldSpec[];
-    /** Per-record instance objects, keyed by field name (Extended only). */
-    instances?: InstanceData[][];
-}
+import { L as Lang, u as uid, a as SidecarUrls, Q as QueueItem, O as Orm } from './orm-MJTHCG9E.js';
+import { P as ParsedSidecar, A as AiResultEntry } from './enriched-index-T0sDG7JR.js';
 
 interface SidecarSet {
     objectType: number;
@@ -77,8 +7,9 @@ interface SidecarSet {
     slim?: ParsedSidecar;
     extended?: ParsedSidecar;
     prov?: ParsedSidecar;
+    ai?: Map<bigint, Map<string, Map<string, Set<AiResultEntry>>>>;
     /** uid -> array index, from the `ids` column of the slim tier. */
-    idIndex: Map<number, number>;
+    idIndex: Map<uid, number>;
 }
 
 interface InitWorkersOptions {
@@ -127,6 +58,12 @@ interface LocalCorpusIndex {
             prov?: {
                 file: string;
             }[];
+            "ai-for-D-safe"?: {
+                file: string;
+            }[];
+            search?: {
+                file: string;
+            }[];
         };
     }>;
 }
@@ -136,6 +73,8 @@ interface RegistryDataBlock {
         slim?: string[];
         extended?: string[];
         prov?: string[];
+        "ai-for-D-safe"?: string[];
+        search?: string[];
     }>>;
 }
 interface BootModelsV2Options {
@@ -154,10 +93,17 @@ interface BootModelsV2Options {
     /** Pre-fetched local manifest (else fetched from `${localMode}/corpus-index.json`). */
     localManifest?: LocalCorpusIndex;
     /** **Registry mode** (used when `localMode` is absent) — resolved registry_v2 data block. */
+    /** **Registry mode** (used when `localMode` is absent) — resolved registry_v2 data block. */
     registry?: {
         dataBlock: RegistryDataBlock;
         gateway?: string;
     };
+    loadAiSidecars?: boolean;
+    /**
+     * Load the Book metadata search index in the background once boot is done
+     * (default true). Never blocks or fails boot; see search/bookSearchService.ts.
+     */
+    search?: boolean;
 }
 /**
  * Full one-shot boot: resolve sidecar URLs (local folder or registry_v2 →
@@ -165,6 +111,37 @@ interface BootModelsV2Options {
  * Returns the worker's `{ sidecars, patches }`.
  */
 declare function bootModelsV2(opts: BootModelsV2Options): Promise<Awaited<ReturnType<typeof InitPatchWorker>>>;
+/**
+ * Start — or retry after an error — loading the search index for `lang` now,
+ * from the same source the session booted from. No-op while it is loading or
+ * loaded; resolves immediately before boot (boot starts it itself).
+ */
+declare function loadSearch(lang?: Lang): Promise<void>;
+declare function hasPartition(basePath: string): boolean;
+/**
+ * Loads and merges an additional local corpus partition — e.g. book-manager's
+ * `deleted/` archive, served alongside the normal `public/` partition it
+ * booted from — into the already-running session, for whichever languages
+ * are already loaded (or an explicit override).
+ *
+ * Local-mode only, unlike `loadLanguage`: deleted partitions are local-only
+ * archives, never published to Arweave/registry (see
+ * slim-versioning-and-historic-index.md), so there is no registry-mode
+ * equivalent to support here.
+ *
+ * Safe to merge: `hydrateAll` reuses an already-materialized record instead
+ * of overwriting it, and the worker's `LoadLanguage` path (reused here) is
+ * additive, so ids already loaded elsewhere are untouched and relation edges
+ * union rather than replace (see hydrateAll's doc comment and
+ * worker/libs/initialLoad.ts). Idempotent per basePath.
+ *
+ * @example
+ * // book-manager, after the normal bootstrapModelsV2({ localMode: '/corpus_v2' }):
+ * await loadPartition('/corpus_v2_deleted');
+ */
+declare function loadPartition(basePath: string, opts?: {
+    langs?: Lang[];
+}): Promise<void>;
 type BootResult = Awaited<ReturnType<typeof bootModelsV2>>;
 interface SessionBootstrapOptions extends BootModelsV2Options {
     /** Optional per-URL hook, fired after each Astro `<ClientRouter />` swap. */
@@ -177,8 +154,33 @@ interface SessionBootstrapOptions extends BootModelsV2Options {
      * (per-username QueueItem arrays). Use this instead of letting the result be discarded.
      */
     onBoot?: (data: BootResult) => void | Promise<void>;
+    /**
+     * Called once boot has failed on every retry (see BOOT_RETRIES below) —
+     * the whole-boot-level backstop behind fetchWithRetry's per-file retries
+     * (worker/libs/initialLoad.ts). Before this existed, a boot failure was
+     * only ever `console.error`'d and silently swallowed — the app was left
+     * in a half-initialized state with no data and no indication anything
+     * was wrong (the 2026-08-21 incident: one Arweave TX not yet retrievable
+     * from a CDN edge killed the entire boot, silently, for every affected
+     * user). Use this to show a "content temporarily unavailable, retry"
+     * prompt instead of leaving the app looking broken with no explanation.
+     */
+    onBootError?: (err: unknown) => void;
 }
 /** Test/HMR helper — forgets the session so the next bootstrap re-inits. */
 declare const resetModelsV2Session: () => void;
+/**
+ * Wipes every locally-queued patch from IndexedDB (all usernames) — the
+ * sanctioned, public entry point for a "discard all local edits, go back to
+ * whatever the sidecars/server say" reset. `indexdb/patch_storage.ts`'s
+ * `clearAllPatches` is deliberately not exported through the package's
+ * public barrel (it bypasses the `Patches` queue/sync invariants — see that
+ * file's header), which is fine here specifically because the caller is
+ * expected to force a full page reload immediately after: there is no
+ * in-memory queue state left to go stale, since nothing survives the reload.
+ * Does not touch `data/patches.jsonl` on the server — callers combine this
+ * with `DELETE /api/patches` (or equivalent) for a full reset.
+ */
+declare const clearLocalPatches: () => Promise<true>;
 
-export { type SessionBootstrapOptions as S, resetModelsV2Session as r };
+export { type SessionBootstrapOptions as S, loadPartition as a, clearLocalPatches as c, hasPartition as h, loadSearch as l, resetModelsV2Session as r };

package/dist/{state-BTsp-E4v.d.ts → state-CkYavOSt.d.ts}

@@ -14,6 +14,9 @@ interface BookData {
     parsed: boolean;
 }
 type WorkerCommand = {
+    type: 'FileInit';
+    gateways: string[];
+} | {
     type: 'GetFile';
     txId: string;
     mime: 'pdf' | 'preview';
@@ -25,12 +28,16 @@ type WorkerCommand = {
 } | {
     type: 'CancelDownload';
     txId: string;
+} | {
+    type: 'PinTxIds';
+    txIds: string[];
 };
 type WorkerMessage = {
     type: 'FileRpcResponse';
     ok: boolean;
     key: string;
     error?: string;
+    quotaExceeded?: boolean;
 } | {
     type: 'HYDRATE';
     payload: HydratePayload;
@@ -49,6 +56,7 @@ type WorkerMessage = {
     txId: string;
     error: string;
     retryable: boolean;
+    quotaExceeded?: boolean;
 } | {
     type: 'StoragePruneStarted';
     targetFreeBytes: number;
@@ -70,6 +78,14 @@ type WorkerMessage = {
     type: 'MuPdfData';
     txId: string;
     bookData: BookData;
+} | {
+    type: 'MuPageCountResult';
+    txId: string;
+    pageCount: number;
+} | {
+    type: 'MuPageCountError';
+    txId: string;
+    error: string;
 };
 interface HydratePayload {
     files: Array<[txId: string, state: FileState$1]>;

package/dist/{types-Dn0EFMO_.d.ts → types-B-IX3HBn.d.ts}

@@ -9,6 +9,9 @@ interface ContractAddresses {
     subscriptionManager?: string;
     libraryRegistryStorage?: string;
     publicLibraryStorage?: string;
+    dSafeHRStorage?: string;
+    relationshipIndexerStorage?: string;
+    accountManager?: string;
 }
 interface StripeDonation {
     stripePaymentId: string;
@@ -37,6 +40,7 @@ interface BouncerStorageReadAPI {
     isAuthorized(address: string): Promise<boolean>;
     getLatestRegisteredUser(): Promise<string | null>;
     getTokenName(): Promise<string>;
+    userIdByEmailHash(emailHash: string): Promise<number>;
 }
 interface ArchivistStorageReadAPI {
     userLevel(userId: number): Promise<number>;
@@ -51,6 +55,13 @@ interface ScientistStorageReadAPI {
     getStatsRaw(action: number, objectType: number, monthId: number): Promise<[bigint[], number[]]>;
     isAuthorized(address: string): Promise<boolean>;
 }
+/** A vote preset: `bps` (1 = 0.01%) of every new credit is voted for this project edition. */
+interface VotePreset {
+    projectId: number;
+    /** Readable code, as getLanguageAtIndex returns it (bytes4 conversion is internal). */
+    lang: string;
+    bps: number;
+}
 interface ProjectManagerStorageReadAPI {
     nbProjects(): Promise<number>;
     getProjectSupportedLanguages(projectId: number): Promise<Array<string>>;
@@ -60,6 +71,7 @@ interface ProjectManagerStorageReadAPI {
         donations: number;
         unspent: number;
     }>;
+    /** Latest versions with resolved public URLs. */
     loadProject(projectId: number): Promise<{
         id: number;
         balance: number;
@@ -74,9 +86,12 @@ interface ProjectManagerStorageReadAPI {
     getNbLanguages(projectId: number): Promise<number>;
     getLanguageAtIndex(projectId: number, index: number): Promise<string>;
     getNbVersions(projectId: number, lang: string): Promise<number>;
+    /** Editable version: owned-site URIs are canonical paths; external URIs are unchanged. */
     getVersion(projectId: number, lang: string, versionNumber: number): Promise<ProjectVersion>;
     getVotingBalance(projectId: number, lang: string): Promise<bigint>;
     getUserBalances(address: string): Promise<[donated: bigint, allocated: bigint, remaining: bigint]>;
+    /** Current vote presets (ProjectManagerStorage 2.1.0+). */
+    getVotePresets(): Promise<VotePreset[]>;
 }
 interface FactoryReadAPI {
     nbWritesByUsername(username: string): Promise<number>;
@@ -90,7 +105,6 @@ interface FactoryReadAPI {
     scientistStorage(): Promise<string>;
     backupStorage(): Promise<string>;
     projectManagerStorage(): Promise<string>;
-    usedPaymentIntents(paymentIntentId: string): Promise<boolean>;
 }
 interface TransactionOptions {
     feeLimit?: number;
@@ -98,19 +112,35 @@ interface TransactionOptions {
     value?: number;
     onAccepted?: (txId: string) => void;
 }
+interface AccountManagerReadAPI {
+    /** Resolved AccountManager address (the one deletion consents are bound to). */
+    address(): Promise<string>;
+    oracleSigner(): Promise<string>;
+    usedDeletionConsents(messageHash: string): Promise<boolean>;
+    /** True once a Stripe payment intent was credited on this network (recorded in ProjectManagerStorage, so it covers every AccountManager). */
+    isPaymentIntentUsed(paymentIntentId: string): Promise<boolean>;
+}
+interface AccountManagerWriteAPI {
+    /** Retires the connected account. Needs the oracle's EmailConsent — see web3/auth/deletionConsent. */
+    unregisterWithConsent(expiry: number, signature: string, options?: TransactionOptions): Promise<any>;
+    registerStripe(country: string, language: string, paymentIntentId: string, votes: bigint, signature: string, emailHash: string, options?: TransactionOptions): Promise<any>;
+    fundStripe(paymentIntentId: string, votes: bigint, signature: string, options?: TransactionOptions): Promise<any>;
+}
+interface BouncerStorageWriteAPI {
+    newAccount(account: string, country: string, language: string, referredBy: number, emailHash: string, options?: TransactionOptions): Promise<any>;
+}
 interface FactoryWriteAPI {
-    register(country: string, language: string, paymentValue: number, options?: TransactionOptions): Promise<any>;
-    unregister(options?: TransactionOptions): Promise<any>;
     save(patches: Array<bigint>, level: number, textIndex: Array<number>, text: Array<string>, options?: TransactionOptions): Promise<any>;
     createProject(lang: string, uri: string, publicationDate: number, name: string, headline: string, arweaveAddressLogo: string, arweaveAddressBanner: string, descriptionMarkdown: string, minimumFundingBeforeStartWork: number, maximumFunding: number, tags: number[], complexity: number, options?: TransactionOptions): Promise<any>;
     addProjectVersion(projectId: number, lang: string, publicationDate: number, uri: string, name: string, headline: string, arweaveAddressLogo: string, arweaveAddressBanner: string, descriptionMarkdown: string, minimumFundingBeforeStartWork: number, maximumFunding: number, tags: number[], status: number, complexity: number, options?: TransactionOptions): Promise<any>;
     deleteProject(projectId: number, lang: string, options?: TransactionOptions): Promise<any>;
-    registerStripe(country: string, language: string, paymentIntentId: string, votes: bigint, signature: string, options?: TransactionOptions): Promise<any>;
-    fundStripe(paymentIntentId: string, votes: bigint, signature: string, options?: TransactionOptions): Promise<any>;
+    /** Replaces the whole vote-preset set in one transaction (Factory owner only). */
+    setVotePresets(presets: VotePreset[], options?: TransactionOptions): Promise<any>;
     donateToProject(projectId: number, lang: string, amount: number, options?: TransactionOptions): Promise<any>;
 }
 interface AddressRegistryWriteAPI {
     addData(key: string, value: string, options?: TransactionOptions): Promise<any>;
+    addBlobRef(key: string, arweaveTxId: string, sha256Hash: string, options?: TransactionOptions): Promise<any>;
 }
 interface AddressRegistryContractRecord {
     contractAddress: string;
@@ -128,6 +158,9 @@ interface AddressRegistryReadAPI {
     getLatestData(key: string): Promise<string>;
     getAllDataKeys(): Promise<string[]>;
     getLastUpdateInfo(name: string): Promise<AddressRegistryUpdateInfo | null>;
+    /** Reverts with "AddressRegistry: blob ref not found" if `key` has no anchor yet. */
+    getLatestBlobRef(key: string): Promise<[arweaveTxId: string, sha256Hash: string]>;
+    getBlobRefHistory(key: string, offset: number, limit: number): Promise<[arweaveTxId: string, sha256Hash: string][]>;
     admin(): Promise<string>;
 }
 interface CollectionInput {
@@ -144,6 +177,7 @@ interface CollectionInput {
     isPublic: boolean;
     initialBookCount: number;
     dSafeBookCount: number;
+    preferredFormat: string;
 }
 interface Collection extends CollectionInput {
     verified: boolean;
@@ -153,6 +187,7 @@ interface Collection extends CollectionInput {
     published: boolean;
 }
 interface LibraryRegistryStorageReadAPI {
+    admin(): Promise<string>;
     getUnverifiedCollectionIds(): Promise<string[]>;
     getVerifiedCollectionIds(): Promise<string[]>;
     getCollection(id: string): Promise<Collection>;
@@ -171,20 +206,6 @@ declare enum LibraryOwnership {
     Public = 0,
     Private = 1
 }
-declare enum PreferredFormat {
-    MARC21 = 0,
-    UNIMARC = 1,
-    MARCXML = 2,
-    DublinCore = 3,
-    MODS = 4,
-    BIBFRAME = 5,
-    ONIX = 6,
-    OPDS = 7,
-    InternetArchive = 8,
-    HathiTrust = 9,
-    EAD = 10,
-    Other = 11
-}
 interface PublicLibraryInput {
     name: string;
     physicalAddress: string;
@@ -192,7 +213,7 @@ interface PublicLibraryInput {
     language: string;
     ownership: LibraryOwnership | number;
     website: string;
-    preferredFormat: PreferredFormat | number;
+    preferredFormat: string;
 }
 interface PublicLibrary extends PublicLibraryInput {
     id: number;
@@ -203,10 +224,13 @@ interface PublicLibraryStorageReadAPI {
     libraryExists(id: number): Promise<boolean>;
     getPublicLibrary(id: number): Promise<PublicLibrary>;
     nbLibraries(): Promise<number>;
+    formatExists(format: string): Promise<boolean>;
+    getAllFormats(): Promise<string[]>;
 }
 interface PublicLibraryStorageWriteAPI {
     addPublicLibrary(input: PublicLibraryInput, options?: TransactionOptions): Promise<any>;
     updatePublicLibrary(id: number, input: PublicLibraryInput, options?: TransactionOptions): Promise<any>;
+    addFormat(format: string, options?: TransactionOptions): Promise<any>;
 }
 interface SubscriptionManagerReadAPI {
     getSubscriptions(userId: number): Promise<number[]>;
@@ -214,6 +238,47 @@ interface SubscriptionManagerReadAPI {
     isSubscribed(subscriber: number, target: number): Promise<boolean>;
     scoreOf(userId: number): Promise<bigint>;
 }
+interface DSafeHRStorageReadAPI {
+    isStaffOf(libraryId: number, caller: string): Promise<boolean>;
+    verifyMember(staff: string): Promise<boolean>;
+    getStaffLibraries(staff: string): Promise<number[]>;
+    getCurrentRecordCounter(libraryId: number, objectType: number): Promise<number>;
+    getLibrarySequence(libraryId: number): Promise<number>;
+    getPublishLock(libraryId: number): Promise<[holder: string, acquiredAt: number, active: boolean]>;
+}
+interface RelationshipRecord {
+    actorId: number;
+    actionId: number;
+    objectType: number;
+    objectId: bigint;
+    tagId: bigint;
+    timestamp: number;
+}
+interface RelationshipIndexerReadAPI {
+    getByObjectTarget(objectType: number, objectId: bigint, start: number, count: number): Promise<RelationshipRecord[]>;
+    getByTagTarget(tagId: bigint, start: number, count: number): Promise<RelationshipRecord[]>;
+    getByActor(actorId: number, start: number, count: number): Promise<RelationshipRecord[]>;
+    countByObjectTarget(objectType: number, objectId: bigint): Promise<number>;
+    countByTagTarget(tagId: bigint): Promise<number>;
+    countByActor(actorId: number): Promise<number>;
+    /**
+     * Returns actor userIds of everyone who interacted with content owned by
+     * `targetUserId` after `since`. The frontend can resolve userIds to usernames
+     * and offer one-click subscribe.
+     */
+    getNewSubscriptionsSince(targetUserId: number, since: number): Promise<number[]>;
+    countNewSubscriptionsSince(targetUserId: number, since: number): Promise<number>;
+}
+interface DSafeHRStorageWriteAPI {
+    addStaff(libraryId: number, staff: string, options?: TransactionOptions): Promise<any>;
+    addStaffBatch(libraryId: number, staffMembers: string[], options?: TransactionOptions): Promise<any>;
+    removeStaff(libraryId: number, staff: string, options?: TransactionOptions): Promise<any>;
+    removeStaffBatch(libraryId: number, staffMembers: string[], options?: TransactionOptions): Promise<any>;
+    acquirePublishLock(libraryId: number, options?: TransactionOptions): Promise<any>;
+    releasePublishLock(libraryId: number, options?: TransactionOptions): Promise<any>;
+    allocateRecordIds(libraryId: number, objectType: number, count: number, options?: TransactionOptions): Promise<any>;
+    bumpLibrarySequence(libraryId: number, options?: TransactionOptions): Promise<any>;
+}
 interface SubscriptionManagerWriteAPI {
     subscribeTo(subscriber: number, target: number, options?: TransactionOptions): Promise<any>;
     unsubscribeFrom(subscriber: number, target: number, options?: TransactionOptions): Promise<any>;
@@ -226,19 +291,27 @@ interface ReadOnlyDomainAPI {
     readonly archivistStorage: ArchivistStorageReadAPI;
     readonly projectManagerStorage: ProjectManagerStorageReadAPI;
     readonly factory: FactoryReadAPI;
+    readonly accountManager: AccountManagerReadAPI;
     readonly addressRegistry: AddressRegistryReadAPI;
     readonly subscriptionManager: SubscriptionManagerReadAPI;
     readonly libraryRegistryStorage: LibraryRegistryStorageReadAPI;
     readonly publicLibraryStorage: PublicLibraryStorageReadAPI;
+    readonly dSafeHRStorage: DSafeHRStorageReadAPI;
+    readonly relationshipIndexerStorage: RelationshipIndexerReadAPI;
     getUsdPrice(): Promise<number>;
     getRegistryStatus(): Promise<any>;
+    getNativeBalance(address: string): Promise<bigint>;
 }
 interface WriteOnlyDomainAPI {
     readonly factory: FactoryWriteAPI;
+    readonly accountManager: AccountManagerWriteAPI;
+    readonly bouncerStorage: BouncerStorageWriteAPI;
     readonly subscriptionManager: SubscriptionManagerWriteAPI;
     readonly addressRegistry: AddressRegistryWriteAPI;
     readonly libraryRegistryStorage: LibraryRegistryStorageWriteAPI;
     readonly publicLibraryStorage: PublicLibraryStorageWriteAPI;
+    readonly dSafeHRStorage: DSafeHRStorageWriteAPI;
+    sendNative(to: string, amountEth: string): Promise<string>;
 }
 interface ProjectVersion {
     uri: string;
@@ -290,4 +363,4 @@ interface EvmWalletConnector extends WalletConnector {
     getWalletClient(chainId: number): Promise<WalletClient>;
 }
 
-export { type AddressRegistryReadAPI as A, type BouncerStorageReadAPI as B, type ConnectResult as C, type EvmWalletConnector as E, type FactoryReadAPI as F, type LibraryRegistryStorageReadAPI as L, type NormalizedError as N, type ProjectVersion as P, type ReadOnlyDomainAPI as R, type ScientistStorageReadAPI as S, type TransactionOptions as T, type WalletType as W, type Project as a, type WalletConnector as b, type ArchivistStorageReadAPI as c, type ProjectManagerStorageReadAPI as d, type SubscriptionManagerReadAPI as e, type PublicLibraryStorageReadAPI as f, type WriteOnlyDomainAPI as g, type FactoryWriteAPI as h, type SubscriptionManagerWriteAPI as i, type AddressRegistryWriteAPI as j, type LibraryRegistryStorageWriteAPI as k, type PublicLibraryStorageWriteAPI as l, type ContractAddresses as m, type StripeDonation as n, type AddressRegistryContractRecord as o, type AddressRegistryUpdateInfo as p, type CollectionInput as q, type Collection as r, LibraryOwnership as s, PreferredFormat as t, type PublicLibraryInput as u, type PublicLibrary as v, type ErrorCode as w };
+export { type AddressRegistryReadAPI as A, type BouncerStorageReadAPI as B, type ConnectResult as C, type DSafeHRStorageReadAPI as D, type EvmWalletConnector as E, type FactoryReadAPI as F, type RelationshipRecord as G, type ErrorCode as H, type LibraryRegistryStorageReadAPI as L, type NormalizedError as N, type ProjectVersion as P, type ReadOnlyDomainAPI as R, type ScientistStorageReadAPI as S, type TransactionOptions as T, type VotePreset as V, type WalletType as W, type Project as a, type WalletConnector as b, type ArchivistStorageReadAPI as c, type AccountManagerReadAPI as d, type ProjectManagerStorageReadAPI as e, type SubscriptionManagerReadAPI as f, type PublicLibraryStorageReadAPI as g, type RelationshipIndexerReadAPI as h, type WriteOnlyDomainAPI as i, type AccountManagerWriteAPI as j, type BouncerStorageWriteAPI as k, type FactoryWriteAPI as l, type SubscriptionManagerWriteAPI as m, type AddressRegistryWriteAPI as n, type LibraryRegistryStorageWriteAPI as o, type PublicLibraryStorageWriteAPI as p, type DSafeHRStorageWriteAPI as q, type ContractAddresses as r, type StripeDonation as s, type AddressRegistryContractRecord as t, type AddressRegistryUpdateInfo as u, type CollectionInput as v, type Collection as w, LibraryOwnership as x, type PublicLibraryInput as y, type PublicLibrary as z };

package/dist/{types-Xb8Ta9tZ.d.ts → types-Blyx2A7F.d.ts}

@@ -1,43 +1,11 @@
-import { Chain } from 'viem';
-import { W as WalletType, P as ProjectVersion, a as Project } from './types-Dn0EFMO_.js';
-
-type ChainPrice = {
-    stable: true;
-} | {
-    stable?: false;
-    pythOracle: string;
-    usdPriceId: string;
-};
-interface EvmChainConfig {
-    chainId: number;
-    name: string;
-    symbol: string;
-    shortName: string;
-    decimals: number;
-    explorer: string;
-    rpc: string;
-    website: string;
-    main: boolean;
-    logo: string;
-    price: ChainPrice;
-    addresses?: {
-        addressRegistry?: string;
-        stagingAddressRegistry?: string;
-        [contract: string]: string | undefined;
-    };
-    deployed?: boolean;
-    stagingDeployed?: boolean;
-}
-declare const EVM_CHAINS: Record<number, EvmChainConfig>;
-declare const DEFAULT_CHAIN_ID = 1116;
-declare function getChain(chainId: number | string): EvmChainConfig;
-declare function toViemChain(config: EvmChainConfig): Chain;
+import { W as WalletType, P as ProjectVersion, a as Project } from './types-B-IX3HBn.js';
 
 interface Web3SessionAccount {
     account: string;
     username: string;
     hasAccount: boolean;
     userId: number;
+    /** Highest local patch sequence acknowledged by an upload (not row count). */
     lastPatchIndex: number;
     lastRestorationIndex: number;
     country?: string;
@@ -82,7 +50,13 @@ interface ProjectLocale {
     version: ProjectVersion;
     balance: number;
 }
-declare const projectLocale: (project: Project, userLanguage: string, chainId: number) => ProjectLocale;
+declare const projectLocale: (project: Project, userLanguage: string, _chainId: number) => ProjectLocale;
+/**
+ * How long a cached project is served without re-reading the chain. Its voting balance moves
+ * with every vote — including the automatic vote-preset share of every new credit — so a
+ * cache that never expires shows stale totals; the stale copy stays the offline fallback.
+ */
+declare const PROJECT_CACHE_TTL_MS: number;
 declare const loadProjects: (chainId: number, language: string) => Promise<Array<ProjectLocale | null>>;
 declare const loadProject: (chainId: number, language: string, projectId: number, refresh?: boolean) => Promise<ProjectLocale>;
 
@@ -152,4 +126,4 @@ interface PatchCacheAdapter {
     set(key: string, patch: Patch): Promise<void>;
 }
 
-export { type ChainPrice as C, DEFAULT_CHAIN_ID as D, type EvmChainConfig as E, type FetchOptions as F, type ProjectLocale as P, type SyncCursor as S, type Web3SessionAccount as W, type SessionStore as a, type SubscriptionNode as b, type WalkOptions as c, type SubscriptionGraph as d, type Patch as e, type SyncOptions as f, type SyncResult as g, type SessionState as h, loadProject as i, type PatchCacheAdapter as j, EVM_CHAINS as k, loadProjects as l, getChain as m, projectLocale as p, toViemChain as t };
+export { type FetchOptions as F, type ProjectLocale as P, type SyncCursor as S, type Web3SessionAccount as W, type SessionStore as a, type SubscriptionNode as b, type WalkOptions as c, type SubscriptionGraph as d, type Patch as e, type SyncOptions as f, type SyncResult as g, type SessionState as h, PROJECT_CACHE_TTL_MS as i, loadProject as j, type PatchCacheAdapter as k, loadProjects as l, projectLocale as p };

package/dist/web3/auth.d.ts

@@ -0,0 +1,89 @@
+import { Hex } from 'viem';
+
+/** A signature older than this is rejected (limits replay of a captured request). */
+declare const BATCH_AUTHORIZATION_MAX_AGE_MS: number;
+/** Tolerated clock skew for an `issuedAt` slightly in the future. */
+declare const BATCH_AUTHORIZATION_MAX_CLOCK_SKEW_MS: number;
+interface BatchAuthorizationPayload {
+    /** Environment the batch is for (`production` / `staging`) — binds the signature to one Lambda. */
+    environment: string;
+    batchId: string;
+    emails: readonly string[];
+    forceSendEmail: boolean;
+    /** ISO-8601 time of signing. */
+    issuedAt: string;
+}
+type BatchAuthorizationFailure = 'invalid_batch_id' | 'invalid_emails' | 'invalid_issued_at' | 'expired' | 'issued_in_future' | 'malformed_signature' | 'signer_mismatch' | 'unauthorized_signer';
+type BatchAuthorizationResult = {
+    ok: true;
+    signer: `0x${string}`;
+    emails: string[];
+} | {
+    ok: false;
+    reason: BatchAuthorizationFailure;
+};
+/** Lowercased, trimmed, de-duplicated and sorted — the exact set the Lambda processes. */
+declare function normalizeBatchEmails(emails: readonly unknown[]): string[];
+/** keccak256 of the JSON-encoded normalized list (JSON so no two lists can encode alike). */
+declare function hashBatchEmails(emails: readonly string[]): Hex;
+declare function createBatchSigningMessage(payload: BatchAuthorizationPayload): string;
+/** Parses a comma-separated admin list (e.g. the AUTHORIZED_ADMINS secret) into checksummed addresses. */
+declare function parseAuthorizedAdmins(list: string | undefined): `0x${string}`[];
+declare function verifyBatchAuthorization(params: {
+    payload: BatchAuthorizationPayload;
+    signature: unknown;
+    authorizedAdmins: readonly string[];
+    /** Optional address the caller claims signed; must match the recovered signer if given. */
+    claimedSigner?: unknown;
+    now?: number;
+}): Promise<BatchAuthorizationResult>;
+
+declare const DELETION_CONSENT_PURPOSE = "EmailConsent";
+/** How long a deletion link stays valid. */
+declare const DELETION_CONSENT_TTL_SECONDS: number;
+interface DeletionConsent {
+    /** Account to retire — the only address allowed to redeem the consent. */
+    account: `0x${string}`;
+    chainId: number;
+    /** AccountManager the consent is for (binds it to one deployment). */
+    accountManager: `0x${string}`;
+    /** Unix seconds after which the contract rejects it. */
+    expiry: number;
+}
+interface SignedDeletionConsent extends DeletionConsent {
+    signature: Hex;
+}
+declare function deletionConsentMessageHash(consent: DeletionConsent): Hex;
+/** Signs as the oracle. `signMessage` is a viem LocalAccount's (or a wallet client's bound) signMessage. */
+declare function signDeletionConsent(consent: DeletionConsent, signMessage: (args: {
+    message: {
+        raw: Hex;
+    };
+}) => Promise<Hex>): Promise<SignedDeletionConsent>;
+type DeletionConsentFailure = 'malformed' | 'expired' | 'wrong_chain' | 'wrong_account_manager' | 'signer_mismatch';
+type DeletionConsentCheck = {
+    ok: true;
+    consent: SignedDeletionConsent;
+} | {
+    ok: false;
+    reason: DeletionConsentFailure;
+};
+/**
+ * The browser-side sanity check before sending the transaction — the contract
+ * repeats all of it, so this only exists to fail early with a clear message.
+ * `oracleSigner` and `accountManager` must come from the chain/registry, never
+ * from the link itself.
+ */
+declare function verifyDeletionConsent(consent: SignedDeletionConsent, expected: {
+    chainId: number;
+    accountManager: string;
+    oracleSigner: string;
+    now?: number;
+}): Promise<DeletionConsentCheck>;
+declare function encodeDeletionConsentToken(consent: SignedDeletionConsent): string;
+/** Parses a token's shape only — call verifyDeletionConsent before trusting it. */
+declare function decodeDeletionConsentToken(token: string): SignedDeletionConsent | null;
+/** The confirmation URL (hash routing, like buildRestoreLink). */
+declare function buildConfirmDeleteLink(token: string, frontendUrl: string): string;
+
+export { BATCH_AUTHORIZATION_MAX_AGE_MS, BATCH_AUTHORIZATION_MAX_CLOCK_SKEW_MS, type BatchAuthorizationFailure, type BatchAuthorizationPayload, type BatchAuthorizationResult, DELETION_CONSENT_PURPOSE, DELETION_CONSENT_TTL_SECONDS, type DeletionConsent, type DeletionConsentCheck, type DeletionConsentFailure, type SignedDeletionConsent, buildConfirmDeleteLink, createBatchSigningMessage, decodeDeletionConsentToken, deletionConsentMessageHash, encodeDeletionConsentToken, hashBatchEmails, normalizeBatchEmails, parseAuthorizedAdmins, signDeletionConsent, verifyBatchAuthorization, verifyDeletionConsent };