@comapeo/core 1.0.0

package/dist/core-manager/index.d.ts

@@ -0,0 +1,125 @@
+export const kCoreManagerReplicate: unique symbol;
+/** @typedef {Hypercore<'binary', Buffer>} Core */
+/** @typedef {{ core: Core, key: Buffer, namespace: Namespace }} CoreRecord */
+/**
+ * @typedef {Object} Events
+ * @property {(coreRecord: CoreRecord) => void} add-core
+ * @property {(namespace: Namespace, msg: { coreDiscoveryId: string, peerId: string, start: number, bitfield: Uint32Array }) => void} peer-have
+ */
+/**
+ * @extends {TypedEmitter<Events>}
+ */
+export class CoreManager extends TypedEmitter<Events> {
+    static get namespaces(): readonly ["auth", "config", "data", "blobIndex", "blob"];
+    /**
+     * @param {Object} options
+     * @param {import('drizzle-orm/better-sqlite3').BetterSQLite3Database} options.db Drizzle better-sqlite3 database instance
+     * @param {import('@mapeo/crypto').KeyManager} options.keyManager mapeo/crypto KeyManager instance
+     * @param {Buffer} options.projectKey 32-byte public key of the project creator core
+     * @param {Buffer} [options.projectSecretKey] 32-byte secret key of the project creator core
+     * @param {Partial<Record<Namespace, Buffer>>} [options.encryptionKeys] Encryption keys for each namespace
+     * @param {import('hypercore').HypercoreStorage} options.storage Folder to store all hypercore data
+     * @param {boolean} [options.autoDownload=true] Immediately start downloading cores - should only be set to false for tests
+     * @param {Logger} [options.logger]
+     */
+    constructor({ db, keyManager, projectKey, projectSecretKey, encryptionKeys, storage, autoDownload, logger, }: {
+        db: import("drizzle-orm/better-sqlite3").BetterSQLite3Database;
+        keyManager: import("@mapeo/crypto/dist/key-manager.js");
+        projectKey: Buffer;
+        projectSecretKey?: Buffer | undefined;
+        encryptionKeys?: Partial<Record<"blob" | "auth" | "config" | "data" | "blobIndex", Buffer>> | undefined;
+        storage: import("hypercore").HypercoreStorage;
+        autoDownload?: boolean | undefined;
+        logger?: Logger | undefined;
+    });
+    get deviceId(): string;
+    get creatorCore(): Core;
+    /**
+     * Resolves when all cores have finished loading
+     *
+     * @returns {Promise<void>}
+     */
+    ready(): Promise<void>;
+    /**
+     * Get the writer core for the given namespace
+     *
+     * @param {Namespace} namespace
+     */
+    getWriterCore(namespace: Namespace): CoreRecord;
+    /**
+     * Get an array of all cores in the given namespace
+     *
+     * @param {Namespace} namespace
+     */
+    getCores(namespace: Namespace): CoreRecord[];
+    /**
+     * Get a core by its public key
+     *
+     * @param {Buffer} key
+     * @returns {Core | undefined}
+     */
+    getCoreByKey(key: Buffer): Core | undefined;
+    /**
+     * Get a core by its discovery key
+     *
+     * @param {Buffer} discoveryKey
+     * @returns {CoreRecord | undefined}
+     */
+    getCoreByDiscoveryKey(discoveryKey: Buffer): CoreRecord | undefined;
+    /**
+     * Close all open cores and end any replication streams
+     * TODO: gracefully close replication streams
+     */
+    close(): Promise<void>;
+    /**
+     * Add a core to the manager (will be persisted across restarts)
+     *
+     * @param {Buffer} key 32-byte public key of core to add
+     * @param {Namespace} namespace
+     * @returns {CoreRecord}
+     */
+    addCore(key: Buffer, namespace: Namespace): CoreRecord;
+    /**
+     * @param {Exclude<Namespace, 'auth'>} namespace
+     * @returns {Promise<void>}
+     */
+    deleteOthersData(namespace: Exclude<Namespace, "auth">): Promise<void>;
+    /**
+     * ONLY FOR TESTING
+     * Replicate all cores in core manager
+     *
+     * NB: Remote peers need to be manually added when unit testing core manager
+     * without the Sync API
+     *
+     * @param {Parameters<Corestore['replicate']>[0]} stream
+     */
+    [kCoreManagerReplicate](stream: Parameters<Corestore["replicate"]>[0]): ReplicationStream;
+    #private;
+}
+export type Core = Hypercore<"binary", Buffer>;
+export type CoreRecord = {
+    core: Core;
+    key: Buffer;
+    namespace: Namespace;
+};
+export type Events = {
+    "add-core": (coreRecord: CoreRecord) => void;
+    "peer-have": (namespace: Namespace, msg: {
+        coreDiscoveryId: string;
+        peerId: string;
+        start: number;
+        bitfield: Uint32Array;
+    }) => void;
+};
+export type HaveMsg = {
+    discoveryKey: Buffer;
+    start: number;
+    bitfield: Uint32Array;
+    namespace: Namespace;
+};
+import { TypedEmitter } from 'tiny-typed-emitter';
+import type { Namespace } from '../types.js';
+import Corestore from 'corestore';
+import { Logger } from '../logger.js';
+import type Hypercore from 'hypercore';
+//# sourceMappingURL=index.d.ts.map

package/dist/core-manager/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core-manager/index.js"],"names":[],"mappings":"AAmBA,kDAAqE;AAErE,kDAAkD;AAClD,8EAA8E;AAC9E;;;;GAIG;AAEH;;GAEG;AACH;IAiBE,kFAEC;IAED;;;;;;;;;;OAUG;IACH,8GATG;QAA4E,EAAE,EAAtE,OAAO,4BAA4B,EAAE,qBAAqB;QACd,UAAU,EAAtD,2CAAkC;QAClB,UAAU,EAA1B,MAAM;QACW,gBAAgB;QACY,cAAc;QACb,OAAO,EAArD,OAAO,WAAW,EAAE,gBAAgB;QAClB,YAAY;QACb,MAAM;KAAC,EAgHlC;IAED,uBAEC;IAED,wBAEC;IAED;;;;OAIG;IACH,SAFa,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;;OAIG;IACH,yBAFW,SAAS,cAInB;IAED;;;;OAIG;IACH,oBAFW,SAAS,gBAInB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,IAAI,GAAG,SAAS,CAK5B;IAED;;;;;OAKG;IACH,oCAHW,MAAM,GACJ,UAAU,GAAG,SAAS,CAOlC;IAED;;;OAGG;IACH,uBAQC;IAED;;;;;;OAMG;IACH,aAJW,MAAM,aACN,SAAS,GACP,UAAU,CAKtB;IAqLD;;;OAGG;IACH,4BAHW,OAAO,CAAC,SAAS,EAAE,MAAM,CAAC,GACxB,OAAO,CAAC,IAAI,CAAC,CAgBzB;IAhCD;;;;;;;;OAQG;IACH,gCAFW,UAAU,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,qBAK/C;;CAqBF;mBAtba,UAAU,QAAQ,EAAE,MAAM,CAAC;yBAC3B;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,SAAS,CAAA;CAAE;;gBAGjD,CAAC,UAAU,EAAE,UAAU,KAAK,IAAI;iBAChC,CAAC,SAAS,EAAE,SAAS,EAAE,GAAG,EAAE;QAAE,eAAe,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,WAAW,CAAA;KAAE,KAAK,IAAI;;;kBAqbtH,MAAM;WACN,MAAM;cACN,WAAW;eACX,SAAS;;6BAldM,oBAAoB;+BAeH,aAAa;sBAdrC,WAAW;uBAMV,cAAc;2BAOV,WAAW"}

package/dist/core-manager/random-access-file-pool.d.ts

@@ -0,0 +1,17 @@
+/**
+ * File descriptor pool for random-access-storage to limit the number of file
+ * descriptors used. Important particularly for Android where the hard limit for
+ * the app is 1024.
+ */
+export class RandomAccessFilePool {
+    /** @param {number} maxSize max number of file descriptors to use */
+    constructor(maxSize: number);
+    maxSize: number;
+    /** @type {Set<import('random-access-file')>} */
+    active: Set<import("random-access-file")>;
+    /** @param {import('random-access-file')} file */
+    _onactive(file: import("random-access-file")): void;
+    /** @param {import('random-access-file')} file */
+    _oninactive(file: import("random-access-file")): void;
+}
+//# sourceMappingURL=random-access-file-pool.d.ts.map

package/dist/core-manager/random-access-file-pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"random-access-file-pool.d.ts","sourceRoot":"","sources":["../../src/core-manager/random-access-file-pool.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH;IACE,oEAAoE;IACpE,qBADY,MAAM,EAKjB;IAHC,gBAAsB;IACtB,gDAAgD;IAChD,QADW,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,CACrB;IAGzB,iDAAiD;IACjD,gBADY,OAAO,oBAAoB,CAAC,QAUvC;IAED,iDAAiD;IACjD,kBADY,OAAO,oBAAoB,CAAC,QAGvC;CACF"}

package/dist/core-manager/remote-bitfield.d.ts

@@ -0,0 +1,146 @@
+export const BITS_PER_PAGE: 32768;
+export default class RemoteBitfield {
+    /** @type {BigSparseArray<RemoteBitfieldPage>} */
+    _pages: BigSparseArray<RemoteBitfieldPage>;
+    /** @type {BigSparseArray<RemoteBitfieldSegment>} */
+    _segments: BigSparseArray<RemoteBitfieldSegment>;
+    _maxSegments: number;
+    /**
+     * @param {number} index
+     */
+    get(index: number): boolean;
+    /**
+     * @param {number} index
+     */
+    getBitfield(index: number): RemoteBitfieldPage | null;
+    /**
+     * @param {number} index
+     * @param {boolean} val
+     */
+    set(index: number, val: boolean): void;
+    /**
+     * @param {number} start
+     * @param {number} length
+     * @param {boolean} val
+     */
+    setRange(start: number, length: number, val: boolean): void;
+    /**
+     * @param {boolean} val
+     * @param {number} position
+     */
+    findFirst(val: boolean, position: number): number;
+    /**
+     * @param {number} position
+     */
+    firstSet(position: number): number;
+    /**
+     * @param {number} position
+     */
+    firstUnset(position: number): number;
+    /**
+     * @param {boolean} val
+     * @param {number} position
+     */
+    findLast(val: boolean, position: number): number;
+    /**
+     * @param {number} position
+     */
+    lastSet(position: number): number;
+    /**
+     * @param {number} position
+     */
+    lastUnset(position: number): number;
+    /**
+     * @param {number} start
+     * @param {Uint32Array} bitfield
+     * @returns {boolean}
+     */
+    insert(start: number, bitfield: Uint32Array): boolean;
+}
+import BigSparseArray from 'big-sparse-array';
+declare class RemoteBitfieldPage {
+    /**
+     *
+     * @param {number} index
+     * @param {Uint32Array} bitfield
+     * @param {RemoteBitfieldSegment} segment
+     */
+    constructor(index: number, bitfield: Uint32Array, segment: RemoteBitfieldSegment);
+    /** @type {typeof index} */
+    index: number;
+    /** @type {number} */
+    offset: number;
+    /** @type {typeof bitfield} */
+    bitfield: Uint32Array;
+    /** @type {typeof segment} */
+    segment: RemoteBitfieldSegment;
+    get tree(): quickbit.SparseIndex;
+    /**
+     *
+     * @param {number} index
+     * @returns {boolean}
+     */
+    get(index: number): boolean;
+    /**
+     *
+     * @param {number} index
+     * @param {boolean} val
+     */
+    set(index: number, val: boolean): void;
+    /**
+     *
+     * @param {number} start
+     * @param {number} length
+     * @param {boolean} val
+     */
+    setRange(start: number, length: number, val: boolean): void;
+    /**
+     *
+     * @param {boolean} val
+     * @param {number} position
+     */
+    findFirst(val: boolean, position: number): number;
+    /**
+     * @param {boolean} val
+     * @param {number} position
+     */
+    findLast(val: boolean, position: number): number;
+    /**
+     *
+     * @param {number} start
+     * @param {Uint32Array} bitfield
+     */
+    insert(start: number, bitfield: Uint32Array): void;
+}
+declare class RemoteBitfieldSegment {
+    /**
+     *
+     * @param {number} index
+     */
+    constructor(index: number);
+    index: number;
+    offset: number;
+    tree: quickbit.SparseIndex;
+    pages: any[];
+    pagesLength: number;
+    get chunks(): quickbit.Chunk[];
+    refresh(): void;
+    /**
+     * @param {RemoteBitfieldPage} page
+     */
+    add(page: RemoteBitfieldPage): void;
+    /**
+     *
+     * @param {boolean} val
+     * @param {number} position
+     */
+    findFirst(val: boolean, position: number): number;
+    /**
+     * @param {boolean} val
+     * @param {number} position
+     */
+    findLast(val: boolean, position: number): number;
+}
+import quickbit from 'quickbit-universal';
+export {};
+//# sourceMappingURL=remote-bitfield.d.ts.map

package/dist/core-manager/remote-bitfield.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-bitfield.d.ts","sourceRoot":"","sources":["../../src/core-manager/remote-bitfield.js"],"names":[],"mappings":"AAOA,kCAAkC;AAsMlC;IAEI,iDAAiD;IACjD,QADW,cAAc,CAAC,kBAAkB,CAAC,CACX;IAClC,oDAAoD;IACpD,WADW,cAAc,CAAC,qBAAqB,CAAC,CACX;IACrC,qBAAqB;IAGvB;;OAEG;IACH,WAFW,MAAM,WAShB;IAED;;OAEG;IACH,mBAFW,MAAM,6BAQhB;IAED;;;OAGG;IACH,WAHW,MAAM,OACN,OAAO,QAsBjB;IAED;;;;OAIG;IACH,gBAJW,MAAM,UACN,MAAM,OACN,OAAO,QA+BjB;IAED;;;OAGG;IACH,eAHW,OAAO,YACP,MAAM,UAqBhB;IACD;;OAEG;IACH,mBAFW,MAAM,UAIhB;IACD;;OAEG;IACH,qBAFW,MAAM,UAIhB;IACD;;;OAGG;IACH,cAHW,OAAO,YACP,MAAM,UAqBhB;IAED;;OAEG;IACH,kBAFW,MAAM,UAIhB;IACD;;OAEG;IACH,oBAFW,MAAM,UAIhB;IACD;;;;OAIG;IACH,cAJW,MAAM,YACN,WAAW,GACT,OAAO,CAuCnB;CACF;2BA3Z0B,kBAAkB;AAU7C;IACE;;;;;OAKG;IACH,mBAJW,MAAM,YACN,WAAW,WACX,qBAAqB,EAa/B;IAVC,2BAA2B;IAC3B,cAAkB;IAClB,qBAAqB;IACrB,QADW,MAAM,CACoC;IACrD,8BAA8B;IAC9B,sBAAwB;IACxB,6BAA6B;IAC7B,+BAAsB;IAKxB,iCAEC;IAED;;;;OAIG;IACH,WAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,WAHW,MAAM,OACN,OAAO,QAMjB;IAED;;;;;OAKG;IACH,gBAJW,MAAM,UACN,MAAM,OACN,OAAO,QASjB;IACD;;;;OAIG;IACH,eAHW,OAAO,YACP,MAAM,UAIhB;IACD;;;OAGG;IACH,cAHW,OAAO,YACP,MAAM,UAIhB;IAED;;;;OAIG;IACH,cAHW,MAAM,YACN,WAAW,QAKrB;CACF;AAED;IACE;;;OAGG;IACH,mBAFW,MAAM,EAUhB;IAPC,cAAkB;IAClB,eAAuC;IACvC,2BAEC;IACD,aAAyC;IACzC,oBAAoB;IAGtB,+BAEC;IAED,gBAIC;IAED;;OAEG;IACH,UAFW,kBAAkB,QAkB5B;IAED;;;;OAIG;IACH,eAHW,OAAO,YACP,MAAM,UAyBhB;IAED;;;OAGG;IACH,cAHW,OAAO,YACP,MAAM,UAyBhB;CACF;qBAtMoB,oBAAoB"}

package/dist/core-ownership.d.ts

@@ -0,0 +1,112 @@
+/**
+ * - Validate that the doc is written to the core identified by doc.authCoreId
+ * - Verify the signatures
+ * - Remove the signatures (we don't add them to the indexer)
+ * - Set doc.links to an empty array - this forces the indexer to treat every
+ *   document as a fork, so getWinner is called for every doc, which resolves to
+ *   the doc with the lowest index (e.g. the first)
+ *
+ * @param {CoreOwnershipWithSignatures} doc
+ * @param {import('@comapeo/schema').VersionIdObject} version
+ * @returns {import('@comapeo/schema').CoreOwnership}
+ */
+export function mapAndValidateCoreOwnership(doc: CoreOwnershipWithSignatures, { coreDiscoveryKey }: import("@comapeo/schema").VersionIdObject): import("@comapeo/schema").CoreOwnership;
+export function getWinner<T extends import("@mapeo/sqlite-indexer").IndexableDocument, U extends import("@mapeo/sqlite-indexer").IndexableDocument>(docA: T, docB: U): T | U;
+/**
+ * @import {
+ *   CoreOwnershipWithSignatures,
+ *   CoreOwnershipWithSignaturesValue,
+ *   KeyPair,
+ *   Namespace
+ * } from './types.js'
+ */
+/**
+ * @typedef {object} CoreOwnershipEvents
+ * @property {(docIds: Set<string>) => void} update Emitted when new coreOwnership records are indexed
+ */
+/**
+ * @extends {TypedEmitter<CoreOwnershipEvents>}
+ */
+export class CoreOwnership extends TypedEmitter<CoreOwnershipEvents> {
+    /**
+     *
+     * @param {object} opts
+     * @param {import('./datatype/index.js').DataType<
+     *   import('./datastore/index.js').DataStore<'auth'>,
+     *   typeof import('./schema/project.js').coreOwnershipTable,
+     *   'coreOwnership',
+     *   import('@comapeo/schema').CoreOwnership,
+     *   import('@comapeo/schema').CoreOwnershipValue
+     * >} opts.dataType
+     * @param {Record<Namespace, KeyPair>} opts.coreKeypairs
+     * @param {KeyPair} opts.identityKeypair
+     */
+    constructor({ dataType, coreKeypairs, identityKeypair }: {
+        dataType: import("./datatype/index.js").DataType<import("./datastore/index.js").DataStore<"auth">, typeof import("./schema/project.js").coreOwnershipTable, "coreOwnership", import("@comapeo/schema").CoreOwnership, import("@comapeo/schema").CoreOwnershipValue>;
+        coreKeypairs: Record<Namespace, KeyPair>;
+        identityKeypair: KeyPair;
+    });
+    /**
+     * @param {string} coreId
+     * @returns {Promise<string>} deviceId of device that owns the core
+     */
+    getOwner(coreId: string): Promise<string>;
+    /**
+     *
+     * @param {string} deviceId
+     * @param {Namespace} namespace
+     * @returns {Promise<string>} coreId of core belonging to `deviceId` for `namespace`
+     */
+    getCoreId(deviceId: string, namespace: Namespace): Promise<string>;
+    /**
+     * Get capabilities for a given deviceId
+     *
+     * @param {string} deviceId
+     */
+    get(deviceId: string): Promise<{
+        schemaName: "coreOwnership";
+        authCoreId: string;
+        configCoreId: string;
+        dataCoreId: string;
+        blobCoreId: string;
+        blobIndexCoreId: string;
+        docId: string;
+        versionId: string;
+        originalVersionId: string;
+        createdAt: string;
+        updatedAt: string;
+        links: string[];
+        deleted: boolean;
+    } & {
+        forks: string[];
+    }>;
+    getAll(): Promise<({
+        schemaName: "coreOwnership";
+        authCoreId: string;
+        configCoreId: string;
+        dataCoreId: string;
+        blobCoreId: string;
+        blobIndexCoreId: string;
+        docId: string;
+        versionId: string;
+        originalVersionId: string;
+        createdAt: string;
+        updatedAt: string;
+        links: string[];
+        deleted: boolean;
+    } & {
+        forks: string[];
+    })[]>;
+    #private;
+}
+export type CoreOwnershipEvents = {
+    /**
+     * Emitted when new coreOwnership records are indexed
+     */
+    update: (docIds: Set<string>) => void;
+};
+import type { CoreOwnershipWithSignatures } from './types.js';
+import { TypedEmitter } from 'tiny-typed-emitter';
+import type { Namespace } from './types.js';
+import type { KeyPair } from './types.js';
+//# sourceMappingURL=core-ownership.d.ts.map

package/dist/core-ownership.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-ownership.d.ts","sourceRoot":"","sources":["../src/core-ownership.js"],"names":[],"mappings":"AAoJA;;;;;;;;;;;GAWG;AACH,iDAJW,2BAA2B,wBAC3B,OAAO,iBAAiB,EAAE,eAAe,GACvC,OAAO,iBAAiB,EAAE,aAAa,CAenD;;AA5JD;;;;;;;GAOG;AAEH;;;GAGG;AAEH;;GAEG;AACH;IAGE;;;;;;;;;;;;OAYG;IACH,yDAVG;QAMQ,QAAQ,EANR,OAAO,qBAAqB,EAAE,QAAQ,CAChD,OAAW,sBAAsB,EAAE,SAAS,CAAC,MAAM,CAAC,EACpD,cAAkB,qBAAqB,EAAE,kBAAkB,EAC3D,eAAmB,EACnB,OAAW,iBAAiB,EAAE,aAAa,EAC3C,OAAW,iBAAiB,EAAE,kBAAkB,CAC7C;QACwC,YAAY,EAA7C,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC;QACZ,eAAe,EAA7B,OAAO;KACjB,EAyBA;IAED;;;OAGG;IACH,iBAHW,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAiB3B;IAED;;;;;OAKG;IACH,oBAJW,MAAM,aACN,SAAS,GACP,OAAO,CAAC,MAAM,CAAC,CAK3B;IAED;;;;OAIG;IACH,cAFW,MAAM;;;;;;;;;;;;;;;;OAKhB;IAED;;;;;;;;;;;;;;;;UAGC;;CAyBF;;;;;YAtHa,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,KAAK,IAAI;;iDALjC,YAAY;6BAPO,oBAAoB;+BAOvC,YAAY;6BAAZ,YAAY"}

package/dist/datastore/index.d.ts

@@ -0,0 +1,91 @@
+/** @import { MapeoDoc } from '@comapeo/schema' */
+/**
+ * For each schemaName in this dataStore, emits an array of docIds that have
+ * been indexed whenever indexing finishes (becomes idle). `projectSettings`
+ * currently not supported.
+ *
+ * @template {MapeoDoc['schemaName']} TSchemaName
+ * @typedef {{
+ *   [S in Exclude<TSchemaName, 'projectSettings'>]: (docIds: Set<string>) => void
+ * }} DataStoreEvents
+ */
+/**
+ * @template T
+ * @template {keyof any} K
+ * @typedef {T extends any ? Omit<T, K> : never} OmitUnion
+ */
+/**
+ * @typedef {typeof NAMESPACE_SCHEMAS} NamespaceSchemas
+ */
+/**
+ * @template {keyof NamespaceSchemas} [TNamespace=keyof NamespaceSchemas]
+ * @template {NamespaceSchemas[TNamespace][number]} [TSchemaName=NamespaceSchemas[TNamespace][number]]
+ * @extends {TypedEmitter<DataStoreEvents<TSchemaName>>}
+ */
+export class DataStore<TNamespace extends keyof NamespaceSchemas = "auth" | "config" | "data", TSchemaName extends NamespaceSchemas[TNamespace][number] = {
+    readonly data: readonly ["observation", "track"];
+    readonly config: readonly ["translation", "preset", "field", "projectSettings", "deviceInfo", "icon"];
+    readonly auth: readonly ["coreOwnership", "role"];
+}[TNamespace][number]> extends TypedEmitter<DataStoreEvents<TSchemaName>> {
+    /**
+     * @param {object} opts
+     * @param {import('../core-manager/index.js').CoreManager} opts.coreManager
+     * @param {TNamespace} opts.namespace
+     * @param {(entries: MultiCoreIndexer.Entry<'binary'>[]) => Promise<import('../index-writer/index.js').IndexedDocIds>} opts.batch
+     * @param {MultiCoreIndexer.StorageParam} opts.storage
+     */
+    constructor({ coreManager, namespace, batch, storage }: {
+        coreManager: import("../core-manager/index.js").CoreManager;
+        namespace: TNamespace;
+        batch: (entries: MultiCoreIndexer.Entry<"binary">[]) => Promise<import("../index-writer/index.js").IndexedDocIds>;
+        storage: MultiCoreIndexer.StorageParam;
+    });
+    get indexer(): MultiCoreIndexer<"binary">;
+    get namespace(): TNamespace;
+    get schemas(): ("observation" | "track")[] | ("translation" | "preset" | "field" | "projectSettings" | "deviceInfo" | "icon")[] | ("coreOwnership" | "role")[];
+    get writerCore(): import("../core-manager/index.js").Core;
+    getIndexState(): import("multi-core-indexer/types/lib/types.js").IndexState;
+    /**
+     * UNSAFE: Does not check links: [] refer to a valid doc - should only be used
+     * internally.
+     *
+     * Write a doc, must be one of the schema types supported by the namespace of
+     * this DataStore.
+     * @template {Extract<Parameters<encode>[0], { schemaName: TSchemaName }>} TDoc
+     * @param {TDoc} doc
+     * @returns {Promise<Extract<MapeoDoc, TDoc>>}
+     */
+    write<TDoc extends Extract<Parameters<typeof encode>[0], {
+        schemaName: TSchemaName;
+    }>>(doc: TDoc): Promise<Extract<MapeoDoc, TDoc>>;
+    /**
+     *
+     * @param {string} versionId
+     * @returns {Promise<MapeoDoc>}
+     */
+    read(versionId: string): Promise<MapeoDoc>;
+    /** @param {Buffer} buf */
+    writeRaw(buf: Buffer): Promise<string>;
+    /** @param {string} versionId */
+    readRaw(versionId: string): Promise<Buffer>;
+    close(): Promise<void>;
+    /**
+     * Unlink all index files. This should only be called after `close()` has resolved.
+     */
+    unlink(): Promise<void>;
+    #private;
+}
+/**
+ * For each schemaName in this dataStore, emits an array of docIds that have
+ * been indexed whenever indexing finishes (becomes idle). `projectSettings`
+ * currently not supported.
+ */
+export type DataStoreEvents<TSchemaName extends MapeoDoc["schemaName"]> = { [S in Exclude<TSchemaName, "projectSettings">]: (docIds: Set<string>) => void; };
+export type OmitUnion<T, K extends keyof any> = T extends any ? Omit<T, K> : never;
+export type NamespaceSchemas = typeof NAMESPACE_SCHEMAS;
+import { TypedEmitter } from 'tiny-typed-emitter';
+import MultiCoreIndexer from 'multi-core-indexer';
+import { encode } from '@comapeo/schema';
+import type { MapeoDoc } from '@comapeo/schema';
+import { NAMESPACE_SCHEMAS } from '../constants.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/datastore/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/datastore/index.js"],"names":[],"mappings":"AAOA,kDAAkD;AAElD;;;;;;;;;GASG;AACH;;;;GAIG;AAEH;;GAEG;AAEH;;;;GAIG;AACH,uBAJuC,UAAU,SAApC,MAAO,gBAAiB,+BACgB,WAAW,SAAlD,gBAAgB,CAAC,UAAU,CAAC,CAAC,MAAM,CAAE;;;;;IAgBjD;;;;;;OAMG;IACH,wDALG;QAA6D,WAAW,EAAhE,OAAO,0BAA0B,EAAE,WAAW;QAC7B,SAAS,EAA1B,UAAU;QACuG,KAAK,EAAtH,CAAC,OAAO,EAAE,gBAAgB,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,KAAK,OAAO,CAAC,OAAO,0BAA0B,EAAE,aAAa,CAAC;QACtE,OAAO,EAA3C,gBAAgB,CAAC,YAAY;KACvC,EAqBA;IAED,0CAEC;IAED,4BAEC;IAED,+JAGC;IAED,0DAEC;IAED,4EAEC;IAkCD;;;;;;;;;OASG;IACH,MAJ2E,IAAI,SAAjE,OAAO,CAAC,UAAU,eAAQ,CAAC,CAAC,CAAC,EAAE;QAAE,UAAU,EAAE,WAAW,CAAA;KAAE,CAAE,OAC/D,IAAI,GACF,OAAO,CAAC,OAAO,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC,CAoC5C;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,OAAO,CAAC,QAAQ,CAAC,CAS7B;IAED,0BAA0B;IAC1B,cADY,MAAM,mBAUjB;IAED,gCAAgC;IAChC,mBADY,MAAM,mBAQjB;IAED,uBAEC;IAED;;OAEG;IACH,wBAEC;;CAaF;;;;;;4BA3NqC,WAAW,SAAnC,QAAQ,CAAC,YAAY,CAAE,IACxB,GACP,CAA4C,IAAvC,OAAO,CAAC,WAAW,EAAE,iBAAiB,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,KAAK,IAAI,GAC9E;sBAGS,CAAC,EACW,CAAC,SAAb,MAAO,GAAI,IACX,CAAC,SAAS,GAAG,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,KAAK;+BAIlC,OAAO,iBAAiB;6BA1BR,oBAAoB;6BAEpB,oBAAoB;uBADY,iBAAiB;8BAMhD,iBAAiB;kCAFb,iBAAiB"}

package/dist/datatype/index.d.ts

@@ -0,0 +1,108 @@
+// Typescript was incorrectly compiling declaration files for this, so the
+// declaration for DataType is written manually below, and copied into the
+// `dist` folder at build-time. The types are checked in `test-types/data-types.ts`
+
+import { type MapeoDoc, type MapeoValue } from '@comapeo/schema'
+import {
+  type MapeoDocMap,
+  type MapeoValueMap,
+  type CoreOwnershipWithSignaturesValue,
+} from '../types.js'
+import { type BetterSQLite3Database } from 'drizzle-orm/better-sqlite3'
+import { SQLiteSelectBase } from 'drizzle-orm/sqlite-core'
+import { RunResult } from 'better-sqlite3'
+import type Hypercore from 'hypercore'
+import { TypedEmitter } from 'tiny-typed-emitter'
+import TranslationApi from '../translation-api.js'
+
+type MapeoDocTableName = `${MapeoDoc['schemaName']}Table`
+type GetMapeoDocTables<T> = T[keyof T & MapeoDocTableName]
+/** Union of Drizzle schema tables that correspond to MapeoDoc types (e.g. excluding backlink tables and other utility tables) */
+type MapeoDocTables =
+  | GetMapeoDocTables<typeof import('../schema/project.js')>
+  | GetMapeoDocTables<typeof import('../schema/client.js')>
+type MapeoDocTablesMap = {
+  [K in MapeoDocTables['_']['name']]: Extract<
+    MapeoDocTables,
+    { _: { name: K } }
+  >
+}
+export interface DataTypeEvents<TDoc extends MapeoDoc> {
+  'updated-docs': (docs: TDoc[]) => void
+}
+
+export const kCreateWithDocId: unique symbol
+export const kSelect: unique symbol
+export const kTable: unique symbol
+export const kDataStore: unique symbol
+
+type OmitUnion<T, K extends keyof any> = T extends any ? Omit<T, K> : never
+type ExcludeSchema<
+  T extends MapeoValue,
+  S extends MapeoValue['schemaName']
+> = Exclude<T, { schemaName: S }>
+
+export class DataType<
+  TDataStore extends import('../datastore/index.js').DataStore,
+  TTable extends MapeoDocTables,
+  TSchemaName extends TTable['_']['name'],
+  TDoc extends MapeoDocMap[TSchemaName],
+  TValue extends MapeoValueMap[TSchemaName]
+> extends TypedEmitter<DataTypeEvents<TDoc>> {
+  constructor({
+    dataStore,
+    table,
+    db,
+    getTranslations,
+  }: {
+    table: TTable
+    dataStore: TDataStore
+    db: import('drizzle-orm/better-sqlite3').BetterSQLite3Database
+    getTranslations: TranslationApi['get']
+  })
+
+  get [kTable](): TTable
+
+  get [kDataStore](): TDataStore
+
+  get schemaName(): TSchemaName
+
+  get namespace(): TDataStore.namespace
+
+  [kCreateWithDocId](
+    docId: string,
+    value:
+      | ExcludeSchema<TValue, 'coreOwnership'>
+      | CoreOwnershipWithSignaturesValue
+  ): Promise<TDoc & { forks: string[] }>
+
+  [kSelect](): Promise<SQLiteSelectBase<TTable, 'sync', RunResult>>
+
+  create<
+    T extends import('type-fest').Exact<
+      ExcludeSchema<TValue, 'coreOwnership'>,
+      T
+    >
+  >(value: T): Promise<TDoc & { forks: string[] }>
+
+  getByDocId(
+    docId: string,
+    opts?: { lang?: string }
+  ): Promise<TDoc & { forks: string[] }>
+
+  getByVersionId(versionId: string, opts?: { lang?: string }): Promise<TDoc>
+
+  getMany(opts?: {
+    includeDeleted?: boolean
+    lang?: string
+  }): Promise<Array<TDoc & { forks: string[] }>>
+
+  update<
+    T extends import('type-fest').Exact<
+      ExcludeSchema<TValue, 'coreOwnership'>,
+      T
+    >
+  >(versionId: string | string[], value: T): Promise<TDoc & { forks: string[] }>
+
+  delete(docId: string): Promise<TDoc & { forks: string[] }>
+}