@the_library/public 1.0.0

package/dist/orm-BvkX0aBT.d.ts

@@ -0,0 +1,507 @@
+declare enum PatchOperation {
+    EditPropertyString = 1,
+    EditPropertyNumber = 2,
+    EditInstanceFieldString = 3,
+    EditInstanceFieldNumber = 4,
+    EditRelation = 5,
+    SetAlias = 6,
+    CreateRecord = 7,
+    AddInstance = 8
+}
+declare enum PatchAction {
+    Remove = 0,
+    Add = 1
+}
+interface BasePatch {
+    operation: PatchOperation;
+    objectType: number;
+    objectId: number;
+    langId: number;
+}
+interface EditPropertyNumberObj extends BasePatch {
+    operation: PatchOperation.EditPropertyNumber;
+    propertyId: number;
+    value: number;
+}
+interface EditPropertyStringObj extends BasePatch {
+    operation: PatchOperation.EditPropertyString;
+    propertyId: number;
+    value: string;
+}
+interface EditInstanceFieldNumberObj extends BasePatch {
+    operation: PatchOperation.EditInstanceFieldNumber;
+    instanceIndex: number;
+    propertyId: number;
+    value: number;
+}
+interface EditInstanceFieldStringObj extends BasePatch {
+    operation: PatchOperation.EditInstanceFieldString;
+    instanceIndex: number;
+    propertyId: number;
+    value: string;
+}
+interface EditRelationObj extends BasePatch {
+    operation: PatchOperation.EditRelation;
+    relationId: number;
+    action: PatchAction;
+    targetId: number;
+}
+interface SetAliasObj {
+    operation: PatchOperation.SetAlias;
+    objectType: number;
+    fromUid: number;
+    toUid: number;
+}
+interface CreateRecordObj {
+    operation: PatchOperation.CreateRecord;
+    objectType: number;
+    objectId: number;
+    langId: 0;
+}
+interface AddInstanceObj extends BasePatch {
+    operation: PatchOperation.AddInstance;
+    objectType: number;
+    objectId: number;
+    langId: number;
+    instanceIndex: number;
+}
+type AnyPatch = EditPropertyNumberObj | EditPropertyStringObj | EditInstanceFieldNumberObj | EditInstanceFieldStringObj | EditRelationObj | SetAliasObj | CreateRecordObj | AddInstanceObj;
+interface EnumLayout {
+    bits: number;
+    values: string[];
+}
+interface PropLayout {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'enum';
+    bits: number;
+    enum?: string;
+}
+interface VersionEntry {
+    hash: string;
+    enums: Record<string, EnumLayout>;
+    props: Record<number, PropLayout>;
+    instanceFields: Record<number, number[]>;
+}
+interface VersionsFile {
+    current: number;
+    versions: Record<number, VersionEntry>;
+}
+interface VersionLayout {
+    hash: string;
+    enums: Record<string, EnumLayout>;
+    props: Record<number, PropLayout>;
+    instanceFields: Record<number, number[]>;
+}
+interface EvmPayload {
+    version: number;
+    patches: bigint[];
+    textIndex: number[];
+    textData: string[];
+}
+declare const LANG_ID_ENCODE: Record<string, number>;
+declare const LANG_ID_DECODE: Record<number, string>;
+
+/**
+ * Merges all version delta entries up to and including `version`.
+ *
+ * WARNING: COUPLING CONTRACT
+ * \`resolveLayout\` relies on \`computeVersionDelta\` emitting the FULL \`instanceFields\`
+ * array for any model that changed. It blindly overwrites the merged layout with the
+ * delta entry's array (\`merged.instanceFields[ot] = [...fields]\`). If future
+ * optimizations shrink \`versions.json\` by emitting only newly added fields, this
+ * function will silently corrupt the field layout by deleting historical fields.
+ */
+declare function resolveLayout(version: number, versionsFile: VersionsFile): VersionLayout;
+declare function packPatch(patch: AnyPatch, layout: VersionLayout): bigint;
+declare function unpackPatch(packed: bigint, layout: VersionLayout): AnyPatch;
+declare function patchToEvm(patches: AnyPatch[], layout: VersionLayout, version: number): EvmPayload;
+declare function evmToPatch(payload: EvmPayload, versionsFile: VersionsFile): AnyPatch[];
+
+declare enum LifecycleStatus {
+    Provisional = 0,
+    Submitted = 1,
+    CommunityPending = 2,
+    Canonical = 3
+}
+
+/**
+ * Local-only, non-EVM operations (analytics, local state).
+ * EVM-bound mutations use `PatchOperation` from `@the_library/db_schemas`
+ * (re-exported in `binary.ts`) — do not add EVM operation variants here.
+ */
+declare enum ActionTypes {
+    Visit = 0,
+    VisitPart = 1,
+    Download = 2,
+    Rate = 3,
+    RatePart = 4,
+    Share = 5,
+    SharePart = 6
+}
+declare enum WorkerCommands {
+    Init = "init",// Initial load: fetch sidecars + local patches
+    SavePatches = "savePatches",
+    GetRecord = "getRecord",// LRU on-demand re-hydration (SPEC §2.5)
+    LoadLanguage = "loadLanguage"
+}
+declare enum Rating {
+    None = 0,
+    New = 1,
+    Keep = 2,
+    Trash = 3,
+    Shared = 4
+}
+declare enum WorkerEvent {
+    WorkerReady = "workerready",
+    WorkerLoadingError = "workerLoadingError",
+    DownloadStarted = "downloadStarted",
+    DownloadFinished = "downloadFinished",
+    DownloadError = "downloadError",
+    LevelUpdated = "levelUpdated"
+}
+declare enum DownloadState {
+    Unknown = 0,
+    Pending = 1,
+    InProgress = 2,
+    Done = 3,
+    Error = 4
+}
+/** Sidecar type byte in the DPM1 wire header (SPEC §4.1). */
+declare enum SidecarType {
+    Slim = 0,
+    Extended = 1,
+    Provenance = 2
+}
+
+type Lang = string;
+type uid = number;
+interface RecordIdentityCluster {
+    sfcuid: string;
+    native: string;
+    aliases: string[];
+    wireId: number;
+}
+/**
+ * Key used in per-language value maps when a value is language-agnostic
+ * (patches with langId 0).
+ */
+declare const LANG_AGNOSTIC: Lang;
+/**
+ * One embedded instance (e.g. a PDF variant of a Book). Keys are the
+ * instanceField names from the schema; `isDefault` is appended by the
+ * sidecar writer and is not an instanceField.
+ */
+type InstanceData = Record<string, string | number | boolean | null>;
+/**
+ * V2 in-memory ORM tuple. All value maps are per-language (perLang defaults
+ * to true in the V2 schema); language-agnostic values use LANG_AGNOSTIC ("").
+ */
+type CommonOrmJson = [
+    uid,
+    Map<number, Set<number>>,
+    Map<number, Set<number>>,
+    Map<number, Map<Lang, number>>,
+    Map<number, Map<Lang, boolean>>,
+    Map<number, Map<Lang, string>>,
+    Map<Lang, InstanceData[]>
+];
+/** JSON-compatible serialization of CommonOrmJson (worker <-> main thread). */
+type SerializedCommonOrmJson = [
+    uid,
+    Array<[number, Array<number>]>,
+    Array<[number, Array<number>]>,
+    Array<[number, Array<[Lang, number]>]>,
+    Array<[number, Array<[Lang, boolean]>]>,
+    Array<[number, Array<[Lang, string]>]>,
+    Array<[Lang, InstanceData[]]>
+];
+type PropertyType = 'string' | 'number' | 'boolean' | 'enum';
+interface BaseLocalOp {
+    ts: number;
+    action: ActionTypes;
+    objectType: number;
+    objectId: number;
+}
+interface RateOp extends BaseLocalOp {
+    rate: Rating;
+}
+interface PartOp extends BaseLocalOp {
+    part: number;
+}
+interface RatePartOp extends PartOp {
+    rate: Rating;
+}
+interface ShareOp extends BaseLocalOp {
+    socialMediaId: number;
+}
+interface SharePartOp extends PartOp {
+    socialMediaId: number;
+}
+type LocalOp = RateOp | RatePartOp | PartOp | ShareOp | SharePartOp | BaseLocalOp;
+/**
+ * Anything the patcher queue can hold: EVM-bound V2 patches (`AnyPatch`,
+ * discriminated by `operation`) or local analytics ops (discriminated by `action`).
+ */
+type QueueItem = AnyPatch | LocalOp;
+declare const isEvmPatch: (item: QueueItem) => item is AnyPatch;
+type SidecarUrls = {
+    objectType: number;
+    lang: Lang;
+    slimUrl?: string;
+    extendedUrl?: string;
+    provUrl?: string;
+};
+type InitPayload = {
+    cmd: WorkerCommands.Init;
+    payload: {
+        /** Flattened sidecar URLs for all selected languages. */
+        sidecars: Array<SidecarUrls>;
+        selectedLangs: Lang[];
+    };
+};
+type SavePatchesPayload = {
+    cmd: WorkerCommands.SavePatches;
+    payload: {
+        username: string;
+        patches: Array<QueueItem>;
+    };
+};
+type GetRecordPayload = {
+    cmd: WorkerCommands.GetRecord;
+    payload: {
+        objectType: number;
+        id: uid;
+    };
+};
+type LoadLanguagePayload = {
+    cmd: WorkerCommands.LoadLanguage;
+    payload: {
+        lang: Lang;
+        sidecars: Array<SidecarUrls>;
+    };
+};
+type WorkerPayload = InitPayload | SavePatchesPayload | GetRecordPayload | LoadLanguagePayload;
+interface IThread {
+    sendRequest(payload: WorkerPayload, transferables?: Array<any>): Promise<any>;
+}
+type StatSummary = {
+    visits: Array<number>;
+    rating: Rating;
+    socialMediaId: Array<number>;
+    downloads: Array<number>;
+    parts: {
+        [partId: string]: {
+            rating: Rating;
+            socialMediaId: Array<number>;
+            visits: Array<number>;
+        };
+    };
+};
+interface BookData {
+    fileId: string;
+    parsed: boolean;
+    author: string;
+    title: string;
+    dimensions: Array<{
+        width: number;
+        height: number;
+    } | null>;
+}
+interface FileRecord {
+    id: string;
+    creationTime: number;
+    sizeKb: number;
+    content: Uint8Array;
+    local: boolean;
+}
+
+declare const PopulateStatsStore: (operations: Array<LocalOp>) => void;
+declare const DownloadsByType: (objectType: number) => Array<number>;
+declare const VisitsByType: (objectType: number) => Array<number>;
+declare const FavoritesByTypes: (objectType: number) => Array<{
+    id: uid;
+    nbVisits: number;
+    rating: Rating;
+}>;
+declare class Stats {
+    private objectId;
+    protected objectType: number;
+    constructor(objectId: number, objectType: number);
+    favoriteParts(): Array<{
+        partId: number;
+        nbVisits: number;
+        rating: Rating;
+    }>;
+    check(): void;
+    visit(): void;
+    download(): void;
+    get rating(): Rating;
+    set rating(rating: Rating);
+    share(socialMediaId: number): void;
+    ratePart(partId: number, rating: Rating): void;
+    visitPart(partId: number): void;
+}
+
+interface UidFactory {
+    next(): Promise<{
+        wireId: number;
+        localId: number;
+    }>;
+    isUserCreated(wireId: number): boolean;
+}
+
+/**
+ * V2 model definition — the shape of the enriched JSON files in
+ * `@the_library/db_schemas/generated-src/*.json` (frozen numeric IDs).
+ */
+interface SchemaProp {
+    name: string;
+    type: PropertyType;
+    source: 'slim' | 'extended';
+    propId: number;
+    enum?: string;
+    bits?: number;
+    nullable?: boolean;
+}
+interface SchemaInstanceField {
+    name: string;
+    type: PropertyType;
+    propId: number;
+    enum?: string;
+    bits?: number;
+    nullable?: boolean;
+    identityComponent?: boolean;
+    source?: 'slim' | 'extended';
+}
+interface SchemaRelation {
+    name: string;
+    targetType: string;
+    direction: 'has' | 'in';
+    inverted: string;
+    relationId: number;
+}
+/**
+ * Cols field name for a `has`-relation tail. The `authors` relation keeps its
+ * historical `authorIds` name for back-compat; every other relation uses its
+ * schema name directly (e.g. Tag.tags, Tag.books). Single source of truth for
+ * both the codegen (schemaGenerator.ts, which emits `${relationColName(rel)}`
+ * as the ExtendedCols field name) and the runtime reader (orm.ts's
+ * mergeExtended, which must look up that same field name on the incoming cols
+ * object) — they must never drift apart.
+ */
+declare const relationColName: (rel: SchemaRelation) => string;
+interface ModelDefinition {
+    name: string;
+    typePrefix: string;
+    objectId: number;
+    multipleInstances: boolean;
+    uidStrategy?: string | string[];
+    instanceUidStrategy?: string | string[];
+    standardPks?: Record<string, string>;
+    props: SchemaProp[];
+    instanceFields: SchemaInstanceField[];
+    relations: SchemaRelation[];
+}
+declare class SchemaRegistry {
+    private static instance;
+    private schemas;
+    private byName;
+    private constructor();
+    static getInstance(): SchemaRegistry;
+    register(schema: ModelDefinition): void;
+    get(id: number): ModelDefinition;
+    /** Lookup by model name (relation targetType resolution). */
+    getByName(name: string): ModelDefinition | undefined;
+    clear(): void;
+}
+declare const Registry: SchemaRegistry;
+
+declare class Orm extends Stats {
+    readonly _id: uid;
+    protected _boolValues: Map<number, Map<string, boolean>>;
+    protected _stringValues: Map<number, Map<string, string>>;
+    protected _numberValues: Map<number, Map<string, number>>;
+    protected _has: Map<number, Set<number>>;
+    protected _in: Map<number, Set<number>>;
+    /** lang -> instance array (BookInstanceData structs, not ORM objects). */
+    protected _instances: Map<string, InstanceData[]>;
+    /** lang -> propId -> provenance code (2-bit: unset/AI/human/consensus). */
+    protected _provenance: Map<string, Map<number, number>>;
+    schema: ModelDefinition;
+    static createNewRequest(id: uid): CommonOrmJson;
+    static createNewRecord<T extends Orm>(this: {
+        new (json: any, creatorUsername?: string): T;
+        type: number;
+    }, uidFactory: UidFactory, creatorUsername: string): Promise<T>;
+    protected _creatorUsername?: string;
+    get creatorUsername(): string;
+    constructor(objectType: number, json: CommonOrmJson | SerializedCommonOrmJson, creatorUsername?: string);
+    toJSON(): SerializedCommonOrmJson;
+    get id(): number;
+    protected langOf(langId: number): Lang;
+    protected langIdOf(lang?: Lang): number;
+    get title(): string;
+    set title(value: string);
+    getTitle(lang: Lang): string;
+    setTitle(value: string, lang: Lang): void;
+    get description(): string;
+    set description(value: string);
+    getDescription(lang: Lang): string;
+    setDescription(value: string, lang: Lang): void;
+    get originalLang(): string;
+    set originalLang(value: string);
+    getOriginalLang(lang: Lang): string;
+    setOriginalLang(value: string, lang: Lang): void;
+    get ageGradeBand(): number;
+    set ageGradeBand(value: number);
+    get previewTxId(): string;
+    set previewTxId(value: string);
+    get safe(): boolean;
+    set safe(value: boolean);
+    get deleted(): boolean;
+    set deleted(value: boolean);
+    get lifecycleStatus(): LifecycleStatus;
+    set lifecycleStatus(value: LifecycleStatus);
+    protected dispatchString(propertyId: number, value: string, lang?: Lang): void;
+    protected dispatchNumber(propertyId: number, value: number, lang?: Lang): void;
+    protected dispatchRelation(relationId: number, action: PatchAction, targetId: number): void;
+    /**
+     * Raw in-memory relation mutation: no patch is emitted. Used by the
+     * generic inverse propagation in patch() and by generated in-side
+     * relation helpers. Idempotent (Set semantics).
+     */
+    protected applyRelationRaw(direction: 'has' | 'in', relationId: number, action: PatchAction, targetId: number): void;
+    /**
+     * Bulk-restores the inverse (`in`) edges implied by this record's forward
+     * (`has`) relations onto their target records. The sidecar serializes only
+     * the `has` direction (§3.7.1); `mergeExtended` fills `_has`, but the inverse
+     * side (`Person.authorOf`, `Tag.inTags`, …) stays empty until this runs.
+     *
+     * No patch emitted, no reactivity fired (bulk boot path). Idempotent (Set
+     * add). Targets must already be materialized — call after a full
+     * `hydrateAll` pass (see `rebuildInverseRelations`).
+     */
+    restoreInverses(): void;
+    /**
+     * Applies a V2 patch to the in-memory state. Triggers reactivity.
+     */
+    patch(patch: AnyPatch, _isMine?: boolean): void;
+    protected applyInstancePatch(p: EditInstanceFieldStringObj | EditInstanceFieldNumberObj): void;
+    protected getPropType(propId: number): 'string' | 'number' | 'boolean';
+    getProp(propId: number, lang?: Lang): any;
+    /** Direct state write — no patch emitted (used by merge methods). */
+    protected setRaw(propId: number, value: any, lang?: Lang): void;
+    getInstancesData(lang?: Lang): InstanceData[];
+    getDefaultInstanceData(lang?: Lang): InstanceData | undefined;
+    /** Direct state write — no patch emitted (used by mergeExtended/mergeSlim). */
+    setInstancesRaw(lang: Lang, instances: InstanceData[]): void;
+    growInstances(lang: Lang, toIndex: number): void;
+    addInstance(lang?: Lang): number;
+    getProvenance(propId: number, lang?: Lang): number;
+    setProvenanceRaw(lang: Lang, propId: number, value: number): void;
+    mergeSlim(cols: any, index: number, lang?: Lang): void;
+    mergeExtended(cols: any, index: number, lang?: Lang): void;
+    mergeProv(cols: any, index: number, lang?: Lang): void;
+}
+
+export { LANG_ID_DECODE as $, type AnyPatch as A, type BookData as B, type CommonOrmJson as C, DownloadState as D, type EvmPayload as E, type FileRecord as F, type GetRecordPayload as G, SchemaRegistry as H, type InstanceData as I, Registry as J, PatchOperation as K, type Lang as L, type ModelDefinition as M, PatchAction as N, Orm as O, type PropertyType as P, type QueueItem as Q, type RecordIdentityCluster as R, SidecarType as S, packPatch as T, unpackPatch as U, type VersionsFile as V, WorkerCommands as W, resolveLayout as X, patchToEvm as Y, evmToPatch as Z, LANG_ID_ENCODE as _, type SidecarUrls as a, type BasePatch as a0, type EditPropertyStringObj as a1, type EditPropertyNumberObj as a2, type EditInstanceFieldStringObj as a3, type EditInstanceFieldNumberObj as a4, type EditRelationObj as a5, type SetAliasObj as a6, type CreateRecordObj as a7, type AddInstanceObj as a8, type VersionEntry as a9, type EnumLayout as aa, type PropLayout as ab, PopulateStatsStore as ac, DownloadsByType as ad, VisitsByType as ae, FavoritesByTypes as af, Stats as ag, type SerializedCommonOrmJson as b, type VersionLayout as c, type IThread as d, ActionTypes as e, Rating as f, WorkerEvent as g, LANG_AGNOSTIC as h, type BaseLocalOp as i, type RateOp as j, type PartOp as k, type RatePartOp as l, type ShareOp as m, type SharePartOp as n, type LocalOp as o, isEvmPatch as p, type InitPayload as q, type SavePatchesPayload as r, type LoadLanguagePayload as s, type WorkerPayload as t, type uid as u, type StatSummary as v, type SchemaProp as w, type SchemaInstanceField as x, type SchemaRelation as y, relationColName as z };

package/dist/session-vqOnyxga.d.ts

@@ -0,0 +1,184 @@
+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[][];
+}
+
+interface SidecarSet {
+    objectType: number;
+    lang: Lang;
+    slim?: ParsedSidecar;
+    extended?: ParsedSidecar;
+    prov?: ParsedSidecar;
+    /** uid -> array index, from the `ids` column of the slim tier. */
+    idIndex: Map<number, number>;
+}
+
+interface InitWorkersOptions {
+    workerPath?: string | URL;
+    sidecars: Array<SidecarUrls>;
+    selectedLangs: Lang[];
+    /** LRU limit per objectType — default 10 000 (use ~2 000 on mobile). */
+    cacheLimit?: number;
+}
+declare const InitPatchWorker: (options: InitWorkersOptions) => Promise<{
+    sidecars: Array<SidecarSet>;
+    patches: {
+        [user: string]: Array<QueueItem>;
+    };
+}>;
+
+/**
+ * Front-end boot orchestration for `@the_library/public/models`.
+ *
+ * Framework-agnostic: resolves sidecar locations (local folder OR registry_v2 →
+ * Arweave), spins up the worker, **eagerly hydrates the full corpus into the
+ * ORM**, and replays local patches. Framework adapters (e.g. the Solid
+ * `bootstrapModelsV2`) wrap this with reactivity + navigation persistence.
+ *
+ * Layer-clean: takes the registry data block structurally (no
+ * `web3-registry-addresses` dependency) and the model constructors from the
+ * caller (no constructor registry needed).
+ */
+
+/** Per-objectType constructor the caller supplies (e.g. `{ type: Book.type, create: NewBookWithId }`). */
+interface ModelFactory {
+    type: number;
+    create: (id: uid) => Orm;
+}
+/** Local `corpus-index.json` shape (the build artifact of `build-v2-corpus.ts`). */
+interface LocalCorpusIndex {
+    lang?: string;
+    objects: Record<string, {
+        tiers: {
+            slim?: {
+                file: string;
+            }[];
+            extended?: {
+                file: string;
+            }[];
+            prov?: {
+                file: string;
+            }[];
+        };
+    }>;
+}
+/** registry_v2 manifest data block: `objects[type][lang][tier] = [txid, …]`. */
+interface RegistryDataBlock {
+    objects?: Record<string, Record<string, {
+        slim?: string[];
+        extended?: string[];
+        prov?: string[];
+    }>>;
+}
+interface BootModelsV2Options {
+    /** Primary session language */
+    userLang: Lang;
+    /** Per-objectType constructors, e.g. `[{type:Book.type,create:NewBookWithId}, …]`. */
+    models: ModelFactory[];
+    selectedLangs?: Lang[];
+    /** Worker bundle URL (default `/patch-worker.js`). */
+    workerPath?: string | URL;
+    /**
+     * **Local mode** — base URL/path serving the `bin/` folder + `corpus-index.json`
+     * (book-manager dev: e.g. `/corpus_v2`). When set, the registry is ignored.
+     */
+    localMode?: string;
+    /** 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?: {
+        dataBlock: RegistryDataBlock;
+        gateway?: string;
+    };
+}
+/**
+ * Full one-shot boot: resolve sidecar URLs (local folder or registry_v2 →
+ * Arweave) → init worker → eagerly hydrate the corpus → replay local patches.
+ * Returns the worker's `{ sidecars, patches }`.
+ */
+declare function bootModelsV2(opts: BootModelsV2Options): Promise<Awaited<ReturnType<typeof InitPatchWorker>>>;
+type BootResult = Awaited<ReturnType<typeof bootModelsV2>>;
+interface SessionBootstrapOptions extends BootModelsV2Options {
+    /** Optional per-URL hook, fired after each Astro `<ClientRouter />` swap. */
+    onNavigate?: () => void;
+    /** Escape hatch — custom one-time boot, bypassing `bootModelsV2`'s source resolution. */
+    init?: () => void | Promise<void>;
+    /**
+     * Called once after the full boot completes (worker init + hydration + patch replay).
+     * Receives the raw worker result: `sidecars` (parsed SidecarSet[]) and `patches`
+     * (per-username QueueItem arrays). Use this instead of letting the result be discarded.
+     */
+    onBoot?: (data: BootResult) => void | Promise<void>;
+}
+/** Test/HMR helper — forgets the session so the next bootstrap re-inits. */
+declare const resetModelsV2Session: () => void;
+
+export { type SessionBootstrapOptions as S, resetModelsV2Session as r };