@comapeo/core 1.0.0

package/dist/schema/project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../src/schema/project.js"],"names":[],"mappings":"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"}

package/dist/schema/schema-to-drizzle.d.ts

@@ -0,0 +1,20 @@
+/** @import { MapeoDoc } from '@comapeo/schema' */
+/** @import { MapeoDocMap } from '../types.js' */
+/**
+Convert a JSONSchema definition to a Drizzle Columns Map (the parameter for
+`sqliteTable()`).
+
+**NOTE**: The return of this function is _not_ type-checked (it is coerced with
+`as`, because it's not possible to type-check what this function is doing), but
+the return type _should_ be correct when using this function.
+@template {import('./types.js').JSONSchema7WithProps} TSchema
+NB: The inline typescript checker often marks this next line as an error, but this seems to be a bug with JSDoc parsing - running `tsc` does not show this as an error.
+@template {import('type-fest').Get<TSchema, 'properties.schemaName.const'>} TSchemaName
+@template {TSchemaName extends MapeoDoc['schemaName'] ? MapeoDocMap[TSchemaName] : any} TObjectType
+@param {TSchema} schema
+@returns {import('./types.js').SchemaToDrizzleColumns<TSchema, TObjectType>}
+ */
+export function jsonSchemaToDrizzleColumns<TSchema extends import("./types.js").JSONSchema7WithProps, TSchemaName extends import("type-fest").Get<TSchema, "properties.schemaName.const">, TObjectType extends TSchemaName extends MapeoDoc["schemaName"] ? MapeoDocMap[TSchemaName] : any>(schema: TSchema): import("./types.js").SchemaToDrizzleColumns<TSchema, TObjectType>;
+import type { MapeoDoc } from '@comapeo/schema';
+import type { MapeoDocMap } from '../types.js';
+//# sourceMappingURL=schema-to-drizzle.d.ts.map

package/dist/schema/schema-to-drizzle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-to-drizzle.d.ts","sourceRoot":"","sources":["../../src/schema/schema-to-drizzle.js"],"names":[],"mappings":"AAGA,kDAAkD;AAClD,iDAAiD;AAEjD;;;;;;;;;;;;;GAaG;AACH,2CAPsD,OAAO,SAAnD,OAAQ,YAAY,EAAE,oBAAqB,EAEuB,WAAW,SAA7E,OAAQ,WAAW,EAAE,GAAG,CAAC,OAAO,EAAE,6BAA6B,CAAE,EACa,WAAW,SAAxF,WAAW,SAAS,QAAQ,CAAC,YAAY,CAAC,GAAG,WAAW,CAAC,WAAW,CAAC,GAAG,GAAI,UAC/E,OAAO,GACL,OAAO,YAAY,EAAE,sBAAsB,CAAC,OAAO,EAAE,WAAW,CAAC,CAyD1E;8BAxE6B,iBAAiB;iCACd,aAAa"}

package/dist/schema/types.d.ts

@@ -0,0 +1,98 @@
+import { Includes, ReadonlyDeep } from 'type-fest';
+import { JSONSchema7 as JSONSchema7Writable, JSONSchema7Type } from 'json-schema';
+/** Convert optional properties to nullable */
+export type OptionalToNull<T extends {}> = {
+    [K in keyof T]-?: undefined extends T[K] ? T[K] | null : T[K];
+};
+/** Convert a readonly array/object to writeable */
+type Writable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+/** Type returned by text(columnName, { enum: [] }) */
+type TextBuilder<TName extends string, TEnum extends readonly [string, ...string[]], TNotNull extends boolean, THasDefault extends boolean> = import('drizzle-orm/sqlite-core').SQLiteTextBuilder<{
+    name: TName;
+    data: Writable<TEnum>[number];
+    driverParam: string;
+    columnType: 'SQLiteText';
+    dataType: 'string';
+    enumValues: Writable<TEnum>;
+    notNull: TNotNull;
+    hasDefault: THasDefault;
+}>;
+/** Type returned by integer(columnName, { mode: 'boolean' }) */
+type BooleanBuilder<TName extends string, TNotNull extends boolean, THasDefault extends boolean> = import('drizzle-orm/sqlite-core').SQLiteBooleanBuilder<{
+    name: TName;
+    data: boolean;
+    driverParam: number;
+    columnType: 'SQLiteBoolean';
+    dataType: 'boolean';
+    notNull: TNotNull;
+    hasDefault: THasDefault;
+    enumValues: undefined;
+}>;
+/** Type returned by real(columnName) */
+type RealBuilder<TName extends string, TNotNull extends boolean, THasDefault extends boolean> = import('drizzle-orm/sqlite-core').SQLiteRealBuilder<{
+    name: TName;
+    data: number;
+    driverParam: number;
+    columnType: 'SQLiteReal';
+    dataType: 'number';
+    notNull: TNotNull;
+    hasDefault: THasDefault;
+    enumValues: undefined;
+}>;
+/** Type returned by integer(columnName) */
+type IntegerBuilder<TName extends string, TNotNull extends boolean, THasDefault extends boolean> = import('drizzle-orm/sqlite-core').SQLiteIntegerBuilder<{
+    name: TName;
+    data: number;
+    driverParam: number;
+    columnType: 'SQLiteInteger';
+    dataType: 'number';
+    notNull: TNotNull;
+    hasDefault: THasDefault;
+    enumValues: undefined;
+}>;
+/** Type returned by the `customJson` custom type */
+type JsonBuilder<TName extends string, TData extends unknown, TNotNull extends boolean, THasDefault extends boolean> = import('drizzle-orm/sqlite-core').SQLiteCustomColumnBuilder<{
+    name: TName;
+    data: TData;
+    dataType: 'custom';
+    driverParam: string;
+    columnType: 'SQLiteCustomColumn';
+    notNull: TNotNull;
+    hasDefault: THasDefault;
+    enumValues: undefined;
+}>;
+export type JSONSchema7 = ReadonlyDeep<JSONSchema7Writable>;
+type JsonSchema7Properties = {
+    readonly [K: string]: JSONSchema7;
+};
+export type JSONSchema7WithProps = Omit<JSONSchema7, 'properties'> & {
+    readonly properties: JsonSchema7Properties;
+};
+/** Get the type of a JSONSchema string: array of constants for an enum,
+otherwise string[]. Strangeness is to convert it into the format expected by
+drizzle, which results in the correct type for the field from SQLite */
+type Enum<T extends JSONSchema7, TEnum extends T['enum'] = T['enum']> = TEnum extends readonly [string, ...string[]] ? Writable<TEnum> : T['const'] extends string ? [T['const']] : [string, ...string[]];
+/** True if JSONSchema object has a default */
+type HasDefault<T extends JSONSchema7> = T['default'] extends JSONSchema7Type ? true : false;
+/** True if JSONSchema value is required */
+type IsRequired<T extends JSONSchema7WithProps, U extends string, V extends JSONSchema7['required'] = T['required']> = V extends readonly any[] ? Includes<V, U> : false;
+/**
+ * Convert a JSONSchema to a Drizzle Columns map (e.g. parameter for
+ * `sqliteTable()`). All top-level properties map to SQLite columns, with
+ * `required` properties marked as `NOT NULL`, and JSONSchema `default` will map
+ * to SQLite defaults. Any properties that are of type `object` or `array` in
+ * the JSONSchema will be mapped to a text field, which drizzle will parse and
+ * stringify. Types for parsed JSON will be derived from MapeoDoc types.
+ */
+export type SchemaToDrizzleColumns<T extends JSONSchema7WithProps, TObjectType extends {
+    [K in keyof U]?: any;
+}, U extends JsonSchema7Properties = T['properties']> = {
+    [K in keyof U]: K extends string ? U[K]['type'] extends 'string' ? TextBuilder<K, Enum<U[K]>, IsRequired<T, K>, HasDefault<U[K]>> : U[K]['type'] extends 'boolean' ? BooleanBuilder<K, IsRequired<T, K>, HasDefault<U[K]>> : U[K]['type'] extends 'number' ? RealBuilder<K, IsRequired<T, K>, HasDefault<U[K]>> : U[K]['type'] extends 'integer' ? IntegerBuilder<K, IsRequired<T, K>, HasDefault<U[K]>> : U[K]['type'] extends 'array' | 'object' ? JsonBuilder<K, TObjectType[K], IsRequired<T, K>, HasDefault<U[K]>> : never : never;
+} & {
+    forks: JsonBuilder<'forks', string[], true, false>;
+};
+export type NonEmptyArray<T> = [T, ...T[]];
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/schema/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/schema/types.ts"],"names":[],"mappings":"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"}

package/dist/schema/utils.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Table for storing backlinks, used for indexing. There needs to be one for
+ * each indexed document type
+ * @param {SqliteTable} tableSchema
+ */
+export function backlinkTable(tableSchema: SqliteTable): SQLiteTableWithColumns<{
+    name: string;
+    schema: undefined;
+    columns: {
+        versionId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "versionId";
+            tableName: string;
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, object>;
+    };
+    dialect: "sqlite";
+}>;
+/**
+ * @param {string} tableName
+ */
+export function getBacklinkTableName(tableName: string): string;
+/** @import { SQLiteTableWithColumns } from 'drizzle-orm/sqlite-core' */
+/**
+ * @template {string} [TName=string]
+ * @typedef {SQLiteTableWithColumns<{
+ *   name: TName;
+ *   dialect: 'sqlite';
+ *   schema: string | undefined;
+ *   columns: any
+ * }>} SqliteTable
+ */
+export const BACKLINK_TABLE_POSTFIX: "_backlink";
+export const customJson: <TName extends string>(dbName: TName, fieldConfig?: unknown) => import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
+    name: TName;
+    dataType: "custom";
+    columnType: "SQLiteCustomColumn";
+    data: unknown;
+    driverParam: unknown;
+    enumValues: undefined;
+}>;
+export type SqliteTable<TName extends string = string> = SQLiteTableWithColumns<{
+    name: TName;
+    dialect: "sqlite";
+    schema: string | undefined;
+    columns: any;
+}>;
+import type { SQLiteTableWithColumns } from 'drizzle-orm/sqlite-core';
+//# sourceMappingURL=utils.d.ts.map

package/dist/schema/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/schema/utils.js"],"names":[],"mappings":"AAoBA;;;;GAIG;AACH,2CAFW,WAAW;;;;;;;;;;;;;;;;;;GAOrB;AAED;;GAEG;AACH,gDAFW,MAAM,UAIhB;AA/BD,wEAAwE;AAExE;;;;;;;;GAQG;AAEH,iDAAiD;AAqBjD;;;;;;;GAWE;wBAzCqB,KAAK,SAAf,MAAQ,aACR,uBAAuB;IACnC,IAAQ,EAAE,KAAK,CAAC;IAChB,OAAW,EAAE,QAAQ,CAAC;IACtB,MAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,OAAW,EAAE,GAAG,CAAA;CACb,CAAC;4CATuC,yBAAyB"}

package/dist/sync/core-sync-state.d.ts

@@ -0,0 +1,252 @@
+/**
+ * Derive count for each peer: "want"; "have"; "wanted".
+ *
+ * @param {InternalState} coreState
+ *
+ * @private
+ * Only exporteed for testing
+ */
+export function deriveState(coreState: InternalState): {
+    coreLength: number;
+    localState: LocalCoreState;
+    remoteStates: Record<string, PeerNamespaceState>;
+};
+/**
+ * Apologies for the obscure code. From
+ * https://stackoverflow.com/a/109025/903300
+ * @param {number} n
+ */
+export function bitCount32(n: number): number;
+/** @import { HypercorePeer, HypercoreRemoteBitfield, Namespace } from '../types.js' */
+/**
+ * @typedef {RemoteBitfield} Bitfield
+ */
+/**
+ * @typedef {string} PeerId
+ */
+/**
+ * @typedef {Object} InternalState
+ * @property {number | undefined} length Core length, e.g. how many blocks in the core (including blocks that are not downloaded)
+ * @property {PeerState} localState
+ * @property {Map<PeerId, PeerState>} remoteStates
+ * @property {Map<string, import('./peer-sync-controller.js').PeerSyncController>} peerSyncControllers
+ * @property {Namespace} namespace
+ */
+/**
+ * @typedef {object} LocalCoreState
+ * @property {number} have blocks we have
+ * @property {number} want unique blocks we want from any other peer
+ * @property {number} wanted blocks we want from this peer
+ */
+/**
+ * @typedef {object} PeerNamespaceState
+ * @property {number} have blocks the peer has locally
+ * @property {number} want blocks this peer wants from us
+ * @property {number} wanted blocks we want from this peer
+ * @property {'stopped' | 'starting' | 'started'} status
+ */
+/**
+ * @typedef {object} DerivedState
+ * @property {number} coreLength known (sparse) length of the core
+ * @property {LocalCoreState} localState local state
+ * @property {{ [peerId in PeerId]: PeerNamespaceState }} remoteStates map of state of all known peers
+ */
+/**
+ * Track sync state for a core identified by `discoveryId`. Can start tracking
+ * state before the core instance exists locally, via the "preHave" messages
+ * received over the project creator core.
+ *
+ * Because deriving the state is expensive (it iterates through the bitfields of
+ * all peers), this is designed to be pull-based: the onUpdate event signals
+ * that the state is updated, but does not pass the state. The consumer can
+ * "pull" the state when it wants it via `coreSyncState.getState()`.
+ *
+ * Each peer (including the local peer) has a state of:
+ *
+ * 1. `have` - number of blocks the peer has locally
+ *
+ * 2. `want` - number of blocks this peer wants. For local state, this is the
+ *    number of unique blocks we want from anyone else. For remote peers, it is
+ *    the number of blocks this peer wants from us.
+ *
+ * 3. `wanted` - number of blocks this peer has that's wanted by others. For
+ *    local state, this is the number of unique blocks any of our peers want.
+ *    For remote peers, it is the number of blocks we want from them.
+ */
+export class CoreSyncState {
+    /**
+     * @param {object} opts
+     * @param {() => void} opts.onUpdate Called when a state update is available (via getState())
+     * @param {Map<string, import('./peer-sync-controller.js').PeerSyncController>} opts.peerSyncControllers
+     * @param {Namespace} opts.namespace
+     */
+    constructor({ onUpdate, peerSyncControllers, namespace }: {
+        onUpdate: () => void;
+        peerSyncControllers: Map<string, import("./peer-sync-controller.js").PeerSyncController>;
+        namespace: Namespace;
+    });
+    getState(): DerivedState;
+    /**
+     * Attach a core. The sync state can be initialized without a core instance,
+     * because we could receive peer want and have states via extension messages
+     * before we have the core key that allows us to create a core instance.
+     *
+     * @param {import('hypercore')<'binary', Buffer>} core
+     */
+    attachCore(core: import("hypercore")<"binary", Buffer>): void;
+    /**
+     * Add a pre-emptive "have" bitfield for a peer. This is used when we receive
+     * a peer "have" via extension message - it allows us to have a state for the
+     * peer before the peer actually starts syncing this core
+     *
+     * @param {PeerId} peerId
+     * @param {number} start
+     * @param {Uint32Array} bitfield
+     */
+    insertPreHaves(peerId: PeerId, start: number, bitfield: Uint32Array): void;
+    /**
+     * Add a ranges of wanted blocks for a peer. By default a peer wants all
+     * blocks in a core - calling this will change the peer to only want the
+     * blocks/ranges that are added here
+     *
+     * @param {PeerId} peerId
+     * @param {Array<{ start: number, length: number }>} ranges
+     */
+    setPeerWants(peerId: PeerId, ranges: Array<{
+        start: number;
+        length: number;
+    }>): void;
+    /**
+     * @param {PeerId} peerId
+     */
+    addPeer(peerId: PeerId): void;
+    #private;
+}
+/**
+ * Sync state for a core for a peer. Uses an internal bitfield from Hypercore to
+ * track which blocks the peer has. Default is that a peer wants all blocks, but
+ * can set ranges of "wants". Setting a want range changes all other blocks to
+ * "not wanted"
+ *
+ * @private
+ * Only exported for testing
+ */
+export class PeerState {
+    constructor({ wantAll }?: {
+        wantAll?: boolean | undefined;
+    });
+    /** @type {PeerNamespaceState['status']} */
+    status: PeerNamespaceState["status"];
+    get preHavesBitfield(): RemoteBitfield;
+    /**
+     * @param {number} start
+     * @param {Uint32Array} bitfield
+     */
+    insertPreHaves(start: number, bitfield: Uint32Array): boolean;
+    /**
+     * @param {HypercoreRemoteBitfield} bitfield
+     */
+    setHavesBitfield(bitfield: HypercoreRemoteBitfield): void;
+    /**
+     * Set a range of blocks that a peer wants. This is not part of the Hypercore
+     * protocol, so we need our own extension messages that a peer can use to
+     * inform us which blocks they are interested in. For most cores peers always
+     * want all blocks, but for blob cores often peers only want preview or
+     * thumbnail versions of media
+     *
+     * @param {{ start: number, length: number }} range
+     */
+    setWantRange({ start, length }: {
+        start: number;
+        length: number;
+    }): void;
+    /**
+     * Returns whether the peer has the block at `index`. If a pre-have bitfield
+     * has been passed, this is used if no connected peer bitfield is available.
+     * If neither bitfield is available then this defaults to `false`
+     * @param {number} index
+     */
+    have(index: number): boolean;
+    /**
+     * Return the "haves" for the 32 blocks from `index`, as a 32-bit integer
+     *
+     * @param {number} index
+     * @returns {number} 32-bit number representing whether the peer has or not
+     * the 32 blocks from `index`
+     */
+    haveWord(index: number): number;
+    /**
+     * Returns whether this peer wants block at `index`. Defaults to `true` for
+     * all blocks
+     * @param {number} index
+     */
+    want(index: number): boolean;
+    /**
+     * Return the "wants" for the 32 blocks from `index`, as a 32-bit integer
+     *
+     * @param {number} index
+     * @returns {number} 32-bit number representing whether the peer wants or not
+     * the 32 blocks from `index`
+     */
+    wantWord(index: number): number;
+    #private;
+}
+export type Bitfield = RemoteBitfield;
+export type PeerId = string;
+export type InternalState = {
+    /**
+     * Core length, e.g. how many blocks in the core (including blocks that are not downloaded)
+     */
+    length: number | undefined;
+    localState: PeerState;
+    remoteStates: Map<PeerId, PeerState>;
+    peerSyncControllers: Map<string, import("./peer-sync-controller.js").PeerSyncController>;
+    namespace: Namespace;
+};
+export type LocalCoreState = {
+    /**
+     * blocks we have
+     */
+    have: number;
+    /**
+     * unique blocks we want from any other peer
+     */
+    want: number;
+    /**
+     * blocks we want from this peer
+     */
+    wanted: number;
+};
+export type PeerNamespaceState = {
+    /**
+     * blocks the peer has locally
+     */
+    have: number;
+    /**
+     * blocks this peer wants from us
+     */
+    want: number;
+    /**
+     * blocks we want from this peer
+     */
+    wanted: number;
+    status: "stopped" | "starting" | "started";
+};
+export type DerivedState = {
+    /**
+     * known (sparse) length of the core
+     */
+    coreLength: number;
+    /**
+     * local state
+     */
+    localState: LocalCoreState;
+    /**
+     * map of state of all known peers
+     */
+    remoteStates: { [peerId in PeerId]: PeerNamespaceState; };
+};
+import type { Namespace } from '../types.js';
+import RemoteBitfield from '../core-manager/remote-bitfield.js';
+import type { HypercoreRemoteBitfield } from '../types.js';
+//# sourceMappingURL=core-sync-state.d.ts.map

package/dist/sync/core-sync-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-sync-state.d.ts","sourceRoot":"","sources":["../../src/sync/core-sync-state.js"],"names":[],"mappings":"AA4VA;;;;;;;GAOG;AACH,uCALW,aAAa;;;;EA6DvB;AAED;;;;GAIG;AACH,8BAFW,MAAM,UAMhB;AAnaD,uFAAuF;AAEvF;;GAEG;AACH;;GAEG;AACH;;;;;;;GAOG;AACH;;;;;GAKG;AACH;;;;;;GAMG;AACH;;;;;GAKG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAYE;;;;;OAKG;IACH,0DAJG;QAAyB,QAAQ,EAAzB,MAAM,IAAI;QACgE,mBAAmB,EAA7F,GAAG,CAAC,MAAM,EAAE,OAAO,2BAA2B,EAAE,kBAAkB,CAAC;QACnD,SAAS,EAAzB,SAAS;KACnB,EASA;IAEU,YAAM,YAAY,CAAA;IAY7B;;;;;;OAMG;IACH,iBAFW,OAAO,WAAW,EAAE,QAAQ,EAAE,MAAM,CAAC,QAiC/C;IAED;;;;;;;;OAQG;IACH,uBAJW,MAAM,SACN,MAAM,YACN,WAAW,QAUrB;IAED;;;;;;;OAOG;IACH,qBAHW,MAAM,UACN,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,QAQlD;IAED;;OAEG;IACH,gBAFW,MAAM,QAMhB;;CAiEF;AAED;;;;;;;;GAQG;AACH;IAUE;;OAEC;IALD,2CAA2C;IAC3C,QADW,kBAAkB,CAAC,QAAQ,CAAC,CACrB;IAKlB,uCAEC;IACD;;;OAGG;IACH,sBAHW,MAAM,YACN,WAAW,WAIrB;IACD;;OAEG;IACH,2BAFW,uBAAuB,QAIjC;IACD;;;;;;;;OAQG;IACH,gCAFW;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,QAK3C;IACD;;;;;OAKG;IACH,YAFW,MAAM,WAIhB;IACD;;;;;;OAMG;IACH,gBAJW,MAAM,GACJ,MAAM,CAOlB;IACD;;;;OAIG;IACH,YAFW,MAAM,WAKhB;IACD;;;;;;OAMG;IACH,gBAJW,MAAM,GACJ,MAAM,CASlB;;CACF;uBAnVY,cAAc;qBAGd,MAAM;;;;;YAIL,MAAM,GAAG,SAAS;gBAClB,SAAS;kBACT,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC;yBACtB,GAAG,CAAC,MAAM,EAAE,OAAO,2BAA2B,EAAE,kBAAkB,CAAC;eACnE,SAAS;;;;;;UAIT,MAAM;;;;UACN,MAAM;;;;YACN,MAAM;;;;;;UAIN,MAAM;;;;UACN,MAAM;;;;YACN,MAAM;YACN,SAAS,GAAG,UAAU,GAAG,SAAS;;;;;;gBAIlC,MAAM;;;;gBACN,cAAc;;;;kBACd,GAAG,MAAgB,IAAN,MAAM,GAAG,kBAAkB,GAAE;;+BAjCe,aAAa;2BAD7E,oCAAoC;6CAC4B,aAAa"}

package/dist/sync/namespace-sync-state.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @overload
+ * @returns {SyncState['localState']}
+ */
+export function createState(): SyncState["localState"];
+/**
+ * @overload
+ * @param {import('./core-sync-state.js').PeerNamespaceState['status']} status
+ * @returns {import('./core-sync-state.js').PeerNamespaceState}
+ */
+export function createState(status: import("./core-sync-state.js").PeerNamespaceState["status"]): import("./core-sync-state.js").PeerNamespaceState;
+/** @import { Namespace } from '../types.js' */
+/**
+ * @typedef {Omit<import('./core-sync-state.js').DerivedState, 'coreLength'> & { dataToSync: boolean, coreCount: number }} SyncState
+ */
+/**
+ * @template {Namespace} [TNamespace=Namespace]
+ */
+export class NamespaceSyncState<TNamespace extends Namespace = "blob" | "auth" | "config" | "data" | "blobIndex"> {
+    /**
+     * @param {object} opts
+     * @param {TNamespace} opts.namespace
+     * @param {import('../core-manager/index.js').CoreManager} opts.coreManager
+     * @param {() => void} opts.onUpdate Called when a state update is available (via getState())
+     * @param {Map<string, import('./peer-sync-controller.js').PeerSyncController>} opts.peerSyncControllers
+     */
+    constructor({ namespace, coreManager, onUpdate, peerSyncControllers }: {
+        namespace: TNamespace;
+        coreManager: import("../core-manager/index.js").CoreManager;
+        onUpdate: () => void;
+        peerSyncControllers: Map<string, import("./peer-sync-controller.js").PeerSyncController>;
+    });
+    get namespace(): TNamespace;
+    /** @returns {SyncState} */
+    getState(): SyncState;
+    /**
+     * @param {string} peerId
+     */
+    addPeer(peerId: string): void;
+    #private;
+}
+export type SyncState = Omit<import("./core-sync-state.js").DerivedState, "coreLength"> & {
+    dataToSync: boolean;
+    coreCount: number;
+};
+import type { Namespace } from '../types.js';
+//# sourceMappingURL=namespace-sync-state.d.ts.map

package/dist/sync/namespace-sync-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"namespace-sync-state.d.ts","sourceRoot":"","sources":["../../src/sync/namespace-sync-state.js"],"names":[],"mappings":";;;;AAwIG,+BACU,SAAS,CAAC,YAAY,CAAC,CACnC;;;;;;AAGE,oCACQ,OAAO,sBAAsB,EAAE,kBAAkB,CAAC,QAAQ,CAAC,GACzD,OAAO,sBAAsB,EAAE,kBAAkB,CAC7D;AA9ID,+CAA+C;AAE/C;;GAEG;AAEH;;GAEG;AACH,gCAF0B,UAAU,SAAvB,SAAW;IAYtB;;;;;;OAMG;IACH,uEALG;QAAyB,SAAS,EAA1B,UAAU;QAC2C,WAAW,EAAhE,OAAO,0BAA0B,EAAE,WAAW;QAC7B,QAAQ,EAAzB,MAAM,IAAI;QACgE,mBAAmB,EAA7F,GAAG,CAAC,MAAM,EAAE,OAAO,2BAA2B,EAAE,kBAAkB,CAAC;KAC7E,EAwBA;IAED,4BAEC;IAED,2BAA2B;IAC3B,YADc,SAAS,CA4BtB;IAED;;OAEG;IACH,gBAFW,MAAM,QAMhB;;CAuCF;wBAhIY,IAAI,CAAC,OAAO,sBAAsB,EAAE,YAAY,EAAE,YAAY,CAAC,GAAG;IAAE,UAAU,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE;+BAH1F,aAAa"}

package/dist/sync/peer-sync-controller.d.ts

@@ -0,0 +1,44 @@
+/** @import { CoreRecord } from '../core-manager/index.js' */
+/** @import { Role } from '../roles.js' */
+/** @import { SyncEnabledState } from './sync-api.js' */
+/** @import { Namespace } from '../types.js' */
+/** @import { OpenedNoiseStream } from '../lib/noise-secret-stream-helpers.js' */
+/**
+ * @typedef {Role['sync'][Namespace] | 'unknown'} SyncCapability
+ */
+export class PeerSyncController {
+    /**
+     * @param {object} opts
+     * @param {import('protomux')<OpenedNoiseStream>} opts.protomux
+     * @param {import("../core-manager/index.js").CoreManager} opts.coreManager
+     * @param {import("./sync-state.js").SyncState} opts.syncState
+     * @param {import('../roles.js').Roles} opts.roles
+     * @param {Logger} [opts.logger]
+     */
+    constructor({ protomux, coreManager, syncState, roles, logger }: {
+        protomux: import("protomux")<OpenedNoiseStream>;
+        coreManager: import("../core-manager/index.js").CoreManager;
+        syncState: import("./sync-state.js").SyncState;
+        roles: import("../roles.js").Roles;
+        logger?: Logger | undefined;
+    });
+    get peerKey(): Buffer;
+    get peerId(): string;
+    get syncCapability(): Record<"blob" | "auth" | "config" | "data" | "blobIndex", SyncCapability>;
+    /** @param {SyncEnabledState} syncEnabledState */
+    setSyncEnabledState(syncEnabledState: SyncEnabledState): void;
+    /**
+     * @param {Buffer} discoveryKey
+     */
+    handleDiscoveryKey(discoveryKey: Buffer): void;
+    #private;
+}
+export type PeerState = { [namespace in Namespace]?: import("./core-sync-state.js").PeerNamespaceState; };
+export type SyncStatus = Record<Namespace, "unknown" | "syncing" | "synced">;
+export type SyncCapability = Role["sync"][Namespace] | "unknown";
+import type { SyncEnabledState } from './sync-api.js';
+import type { OpenedNoiseStream } from '../lib/noise-secret-stream-helpers.js';
+import { Logger } from '../logger.js';
+import type { Namespace } from '../types.js';
+import type { Role } from '../roles.js';
+//# sourceMappingURL=peer-sync-controller.d.ts.map

package/dist/sync/peer-sync-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"peer-sync-controller.d.ts","sourceRoot":"","sources":["../../src/sync/peer-sync-controller.js"],"names":[],"mappings":"AAKA,6DAA6D;AAC7D,0CAA0C;AAC1C,wDAAwD;AACxD,+CAA+C;AAC/C,iFAAiF;AAEjF;;GAEG;AAEH;IAqBE;;;;;;;OAOG;IACH,iEANG;QAAoD,QAAQ,EAApD,OAAO,UAAU,EAAE,iBAAiB,CAAC;QACgB,WAAW,EAAhE,OAAO,0BAA0B,EAAE,WAAW;QACJ,SAAS,EAAnD,OAAO,iBAAiB,EAAE,SAAS;QACD,KAAK,EAAvC,OAAO,aAAa,EAAE,KAAK;QACb,MAAM;KAAC,EA2B/B;IAED,sBAEC;IAED,qBAEC;IAED,gGAEC;IAED,iDAAiD;IACjD,sCADY,gBAAgB,QAO3B;IAED;;OAEG;IACH,iCAFW,MAAM,QAgBhB;;CAyLF;wBAGY,GAAG,SAAsB,IAAT,SAAS,CAAC,CAAC,EAAE,OAAO,sBAAsB,EAAE,kBAAkB,GAAE;yBAG/E,MAAM,CAAC,SAAS,EAAE,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC;6BAhSpD,IAAI,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,GAAG,SAAS;sCALV,eAAe;uCAEd,uCAAuC;uBAPvD,cAAc;+BAMN,aAAa;0BAFlB,aAAa"}