@evolu/common 1.0.0

package/dist/src/DbWorker.js

@@ -0,0 +1,282 @@
+import { hexToBytes } from "@noble/ciphers/utils";
+import { Context, Effect, Function, Layer, Match, Option, ReadonlyArray, Ref, pipe, } from "effect";
+import { Config, ConfigLive } from "./Config.js";
+import { Bip39, NanoId } from "./Crypto.js";
+import { Owner, ensureSchema, lazyInit, someDefectToNoSuchTableOrColumnError, transaction, } from "./Db.js";
+import { makePatches } from "./Diff.js";
+import { makeUnexpectedError } from "./Errors.js";
+import { diffMerkleTrees, insertIntoMerkleTree, merkleTreeToString, } from "./MerkleTree.js";
+import { cast } from "./Model.js";
+import { insertIntoMessagesIfNew, insertValueIntoTableRowColumn, selectLastTimestampForTableRowColumn, selectMessagesToSync, selectOwner, selectOwnerTimestampAndMerkleTree, updateOwnerTimestampAndMerkleTree, } from "./Sql.js";
+import { Sqlite, queryObjectFromQuery } from "./Sqlite.js";
+import { SyncWorker, SyncWorkerPostMessage, } from "./SyncWorker.js";
+import { Time, TimeLive, makeSyncTimestamp, receiveTimestamp, sendTimestamp, timestampToString, unsafeTimestampFromString, } from "./Timestamp.js";
+export const DbWorker = Context.Tag("evolu/DbWorker");
+const DbWorkerOnMessage = Context.Tag("evolu/DbWorkerOnMessage");
+const init = (input) => Effect.gen(function* (_) {
+    const sqlite = yield* _(Sqlite);
+    return yield* _(sqlite.exec(selectOwner), Effect.map(({ rows: [row] }) => ({
+        id: row.id,
+        mnemonic: row.mnemonic,
+        // expo-sqlite 11.3.2 doesn't support Uint8Array
+        encryptionKey: hexToBytes(row.encryptionKey),
+    })), someDefectToNoSuchTableOrColumnError, Effect.catchTag("NoSuchTableOrColumnError", () => lazyInit()), Effect.tap(() => ensureSchema(input.tables)));
+});
+const RowsCacheRef = Context.Tag("evolu/RowsCacheRef");
+const query = ({ queries, onCompleteIds = [], }) => Effect.gen(function* (_) {
+    const sqlite = yield* _(Sqlite);
+    const rowsCache = yield* _(RowsCacheRef);
+    const dbWorkerOnMessage = yield* _(DbWorkerOnMessage);
+    const queriesRows = yield* _(Effect.forEach(queries, (query) => sqlite
+        .exec(queryObjectFromQuery(query))
+        .pipe(Effect.map((result) => [query, result.rows]))));
+    const previous = yield* _(Ref.get(rowsCache));
+    yield* _(Ref.set(rowsCache, new Map([...previous, ...queriesRows])));
+    const queriesPatches = queriesRows.map(([query, rows]) => ({
+        query,
+        patches: makePatches(previous.get(query), rows),
+    }));
+    dbWorkerOnMessage({ _tag: "onQuery", queriesPatches, onCompleteIds });
+});
+const readTimestampAndMerkleTree = Sqlite.pipe(Effect.flatMap((sqlite) => sqlite.exec(selectOwnerTimestampAndMerkleTree)), Effect.map((result) => result.rows), Effect.map(([{ timestamp, merkleTree }]) => ({
+    timestamp: unsafeTimestampFromString(timestamp),
+    merkleTree: merkleTree,
+})));
+const mutateItemsToNewMessages = (items) => pipe(items, ReadonlyArray.mapNonEmpty(({ id, isInsert, now, table, values }) => pipe(Object.entries(values), ReadonlyArray.filterMap(([key, value]) => 
+// The value can be undefined if exactOptionalPropertyTypes isn't true.
+// Don't insert nulls because null is the default value.
+value === undefined || (isInsert && value == null)
+    ? Option.none()
+    : Option.some([key, value])), ReadonlyArray.map(([key, value]) => [
+    key,
+    typeof value === "boolean"
+        ? cast(value)
+        : value instanceof Date
+            ? cast(value)
+            : value,
+]), ReadonlyArray.append([isInsert ? "createdAt" : "updatedAt", now]), ReadonlyArray.mapNonEmpty(([key, value]) => ({
+    table,
+    row: id,
+    column: key,
+    value,
+})))), ReadonlyArray.flattenNonEmpty);
+const ensureSchemaByMessages = (messages) => Effect.gen(function* (_) {
+    const tablesMap = new Map();
+    messages.forEach((message) => {
+        const table = tablesMap.get(message.table);
+        if (table == null) {
+            tablesMap.set(message.table, {
+                name: message.table,
+                columns: [message.column],
+            });
+            return;
+        }
+        if (table.columns.includes(message.column))
+            return;
+        tablesMap.set(message.table, {
+            name: message.table,
+            columns: table.columns.concat(message.column),
+        });
+    });
+    yield* _(ensureSchema(Array.from(tablesMap.values())));
+});
+const applyMessages = ({ merkleTree, messages, }) => Effect.gen(function* (_) {
+    const sqlite = yield* _(Sqlite);
+    for (const message of messages) {
+        const timestamp = yield* _(sqlite.exec({
+            sql: selectLastTimestampForTableRowColumn,
+            parameters: [message.table, message.row, message.column],
+        }), Effect.map((result) => result.rows), Effect.flatMap(ReadonlyArray.head), Effect.map((row) => row.timestamp), Effect.catchTag("NoSuchElementException", () => Effect.succeed(null)));
+        if (timestamp == null || timestamp < message.timestamp) {
+            const insert = sqlite.exec({
+                sql: insertValueIntoTableRowColumn(message.table, message.column),
+                parameters: [message.row, message.value, message.value],
+            });
+            yield* _(insert, someDefectToNoSuchTableOrColumnError, Effect.catchTag("NoSuchTableOrColumnError", () => ensureSchemaByMessages(messages).pipe(Effect.flatMap(() => insert))));
+        }
+        if (timestamp == null || timestamp !== message.timestamp) {
+            const { changes } = yield* _(sqlite.exec({
+                sql: insertIntoMessagesIfNew,
+                parameters: [
+                    message.timestamp,
+                    message.table,
+                    message.row,
+                    message.column,
+                    message.value,
+                ],
+            }));
+            if (changes > 0)
+                merkleTree = insertIntoMerkleTree(unsafeTimestampFromString(message.timestamp))(merkleTree);
+        }
+    }
+    return merkleTree;
+});
+const writeTimestampAndMerkleTree = ({ timestamp, merkleTree, }) => Effect.flatMap(Sqlite, (sqlite) => sqlite.exec({
+    sql: updateOwnerTimestampAndMerkleTree,
+    parameters: [
+        timestampToString(timestamp),
+        merkleTreeToString(merkleTree),
+    ],
+}));
+const mutate = ({ items, queries, }) => Effect.gen(function* (_) {
+    const owner = yield* _(Owner);
+    let { timestamp, merkleTree } = yield* _(readTimestampAndMerkleTree);
+    const messages = yield* _(mutateItemsToNewMessages(items), Effect.forEach((newMessage) => Effect.map(sendTimestamp(timestamp), (nextTimestamp) => {
+        timestamp = nextTimestamp;
+        return {
+            ...newMessage,
+            timestamp: timestampToString(timestamp),
+        };
+    })));
+    if (ReadonlyArray.isNonEmptyReadonlyArray(messages)) {
+        merkleTree = yield* _(applyMessages({ merkleTree, messages }));
+        yield* _(writeTimestampAndMerkleTree({ timestamp, merkleTree }));
+    }
+    const onCompleteIds = ReadonlyArray.filterMap(items, (item) => Option.fromNullable(item.onCompleteId));
+    if (queries.length > 0 || onCompleteIds.length > 0)
+        yield* _(query({ queries, onCompleteIds }));
+    const [config, syncWorkerPostMessage] = yield* _(Effect.all([Config, SyncWorkerPostMessage]));
+    syncWorkerPostMessage({
+        _tag: "sync",
+        syncUrl: config.syncUrl,
+        messages,
+        timestamp,
+        merkleTree,
+        owner,
+        syncLoopCount: 0,
+    });
+});
+const handleSyncResponse = ({ messages, ...response }) => Effect.gen(function* (_) {
+    let { timestamp, merkleTree } = yield* _(readTimestampAndMerkleTree);
+    if (ReadonlyArray.isNonEmptyReadonlyArray(messages)) {
+        for (const message of messages)
+            timestamp = yield* _(unsafeTimestampFromString(message.timestamp), (remote) => receiveTimestamp({ local: timestamp, remote }));
+        merkleTree = yield* _(applyMessages({ merkleTree, messages }));
+        yield* _(writeTimestampAndMerkleTree({ timestamp, merkleTree }));
+    }
+    const dbWorkerOnMessage = yield* _(DbWorkerOnMessage);
+    dbWorkerOnMessage({ _tag: "onReceive" });
+    const diff = diffMerkleTrees(response.merkleTree, merkleTree);
+    const syncWorkerPostMessage = yield* _(SyncWorkerPostMessage);
+    if (Option.isNone(diff)) {
+        syncWorkerPostMessage({ _tag: "syncCompleted" });
+        dbWorkerOnMessage({
+            _tag: "onSyncState",
+            state: {
+                _tag: "SyncStateIsSynced",
+                time: yield* _(Time.pipe(Effect.flatMap((time) => time.now))),
+            },
+        });
+        return;
+    }
+    const [sqlite, config, owner] = yield* _(Effect.all([Sqlite, Config, Owner]));
+    const messagesToSync = yield* _(sqlite.exec({
+        sql: selectMessagesToSync,
+        parameters: [timestampToString(makeSyncTimestamp(diff.value))],
+    }), Effect.map(({ rows }) => rows));
+    syncWorkerPostMessage({
+        _tag: "sync",
+        syncUrl: config.syncUrl,
+        messages: messagesToSync,
+        timestamp,
+        merkleTree,
+        owner,
+        syncLoopCount: response.syncLoopCount + 1,
+    });
+});
+const sync = ({ queries, }) => Effect.gen(function* (_) {
+    if (queries.length > 0)
+        yield* _(query({ queries }));
+    const [syncWorkerPostMessage, config, owner, timestampAndMerkleTree] = yield* _(Effect.all([
+        SyncWorkerPostMessage,
+        Config,
+        Owner,
+        readTimestampAndMerkleTree,
+    ]));
+    syncWorkerPostMessage({
+        ...timestampAndMerkleTree,
+        _tag: "sync",
+        syncUrl: config.syncUrl,
+        owner,
+        messages: [],
+        syncLoopCount: 0,
+    });
+});
+const reset = (input) => Effect.gen(function* (_) {
+    const sqlite = yield* _(Sqlite);
+    yield* _(sqlite.exec(`SELECT "name" FROM "sqlite_master" WHERE "type" = 'table'`), Effect.map((result) => result.rows), Effect.flatMap(
+    // The dropped table is completely removed from the database schema and
+    // the disk file. The table can not be recovered.
+    // All indices and triggers associated with the table are also deleted.
+    // https://sqlite.org/lang_droptable.html
+    Effect.forEach(({ name }) => sqlite.exec(`DROP TABLE "${name}"`), { discard: true })));
+    if (input.mnemonic)
+        yield* _(lazyInit(input.mnemonic));
+    const onMessage = yield* _(DbWorkerOnMessage);
+    onMessage({ _tag: "onResetOrRestore" });
+});
+export const DbWorkerLive = Layer.effect(DbWorker, Effect.gen(function* (_) {
+    const syncWorker = yield* _(SyncWorker);
+    const rowsCacheRef = yield* _(Ref.make(new Map()));
+    const onError = (error) => Effect.sync(() => {
+        dbWorker.onMessage({ _tag: "onError", error });
+    });
+    syncWorker.onMessage = (output) => {
+        switch (output._tag) {
+            case "UnexpectedError":
+                onError(output).pipe(Effect.runSync);
+                break;
+            case "SyncWorkerOutputSyncResponse":
+                postMessage(output);
+                break;
+            default:
+                dbWorker.onMessage({ _tag: "onSyncState", state: output });
+        }
+    };
+    const context = Context.empty().pipe(Context.add(Sqlite, yield* _(Sqlite)), Context.add(Bip39, yield* _(Bip39)), Context.add(NanoId, yield* _(NanoId)));
+    const run = (effect) => effect.pipe(Effect.catchAllDefect(makeUnexpectedError), transaction, Effect.catchAll(onError), Effect.provide(context), Effect.runPromise);
+    // Write for reset only in case init fails.
+    const writeForInitFail = (input) => {
+        if (input._tag !== "reset")
+            return Promise.resolve(undefined);
+        return reset(input).pipe(Effect.provideService(DbWorkerOnMessage, dbWorker.onMessage), Effect.provide(context), run);
+    };
+    const makeWriteForInitSuccess = (owner, config) => {
+        let skipAllBecauseOfReset = false;
+        const layer = Layer.mergeAll(ConfigLive(config), Layer.succeed(DbWorkerOnMessage, dbWorker.onMessage), Layer.succeed(Owner, owner), Layer.succeed(SyncWorkerPostMessage, syncWorker.postMessage), Layer.succeed(RowsCacheRef, rowsCacheRef), TimeLive);
+        return (input) => {
+            if (skipAllBecauseOfReset)
+                return Promise.resolve(undefined);
+            return Match.value(input).pipe(Match.tagsExhaustive({
+                init: () => makeUnexpectedError(new Error("init must be called once")),
+                query,
+                mutate,
+                sync,
+                reset: (input) => {
+                    skipAllBecauseOfReset = true;
+                    return reset(input);
+                },
+                ensureSchema: (input) => ensureSchema(input.tables),
+                SyncWorkerOutputSyncResponse: handleSyncResponse,
+            }), Effect.provide(layer), run);
+        };
+    };
+    let write = (input) => {
+        if (input._tag !== "init")
+            return run(makeUnexpectedError(new Error("init must be called first")));
+        write = writeForInitFail;
+        return init(input).pipe(Effect.map((owner) => {
+            dbWorker.onMessage({ _tag: "onOwner", owner });
+            write = makeWriteForInitSuccess(owner, input.config);
+        }), run);
+    };
+    let messageQueue = Promise.resolve(undefined);
+    const postMessage = (input) => {
+        messageQueue = messageQueue.then(() => write(input));
+    };
+    const dbWorker = {
+        postMessage,
+        onMessage: Function.constVoid,
+    };
+    return dbWorker;
+}));

package/dist/src/Diff.d.ts

@@ -0,0 +1,19 @@
+import { Query, Row, Value } from "./Sqlite.js";
+export interface QueryPatches {
+    readonly query: Query;
+    readonly patches: ReadonlyArray<Patch>;
+}
+export type Patch = ReplaceAllPatch | ReplaceAtPatch;
+export interface ReplaceAllPatch {
+    readonly op: "replaceAll";
+    readonly value: ReadonlyArray<Row>;
+}
+export interface ReplaceAtPatch {
+    readonly op: "replaceAt";
+    readonly index: number;
+    readonly value: Row;
+}
+export declare const applyPatches: (patches: ReadonlyArray<Patch>) => (current: ReadonlyArray<Row>) => ReadonlyArray<Row>;
+export declare const makePatches: (previousRows: ReadonlyArray<Row> | undefined, nextRows: ReadonlyArray<Row>) => readonly Patch[];
+export declare const areEqual: (a: Value | Row | ReadonlyArray<Row>, b: Value | Row | ReadonlyArray<Row>) => boolean;
+//# sourceMappingURL=Diff.d.ts.map

package/dist/src/Diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Diff.d.ts","sourceRoot":"","sources":["../../src/Diff.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEhD,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC;CACxC;AAED,MAAM,MAAM,KAAK,GAAG,eAAe,GAAG,cAAc,CAAC;AAErD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,EAAE,YAAY,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,GAAG,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,EAAE,WAAW,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC;CACrB;AAED,eAAO,MAAM,YAAY,YACb,cAAc,KAAK,CAAC,eACpB,cAAc,GAAG,CAAC,KAAG,cAAc,GAAG,CAYnC,CAAC;AAQhB,eAAO,MAAM,WAAW,iBACR,cAAc,GAAG,CAAC,GAAG,SAAS,YAClC,cAAc,GAAG,CAAC,KAC3B,SAAS,KAAK,EA2BhB,CAAC;AAEF,eAAO,MAAM,QAAQ,MAChB,KAAK,GAAG,GAAG,GAAG,cAAc,GAAG,CAAC,KAChC,KAAK,GAAG,GAAG,GAAG,cAAc,GAAG,CAAC,KAClC,OAkCF,CAAC"}

package/dist/src/Diff.js

@@ -0,0 +1,86 @@
+import { Predicate } from "effect/index";
+export const applyPatches = (patches) => (current) => patches.reduce((a, patch) => {
+    switch (patch.op) {
+        case "replaceAll":
+            return patch.value;
+        case "replaceAt": {
+            if (a === undefined)
+                return a;
+            const next = [...a];
+            next[patch.index] = patch.value;
+            return next;
+        }
+    }
+}, current);
+// We detect only a change in the whole result and in-place edits.
+// In the future, we will add more heuristics. We will probably not implement
+// the Myers diff algorithm because it's faster to rerender all than
+// to compute many detailed patches. We will only implement a logic
+// a developer would implement manually, if necessary.
+// Another idea is to make makePatches configurable via custom functions.
+export const makePatches = (previousRows, nextRows) => {
+    if (previousRows === undefined)
+        return [{ op: "replaceAll", value: nextRows }];
+    // TODO: Detect prepend and append, it's cheap.
+    if (previousRows.length !== nextRows.length) {
+        return [{ op: "replaceAll", value: nextRows }];
+    }
+    const length = previousRows.length;
+    const replaceAtPatches = [];
+    for (let i = 0; i < length; i++) {
+        const previousRow = previousRows[i];
+        const nextRow = nextRows[i];
+        // We expect the same shape for both rows.
+        for (const key in previousRow)
+            if (!areEqual(previousRow[key], nextRow[key])) {
+                replaceAtPatches.push({ op: "replaceAt", value: nextRow, index: i });
+                break;
+            }
+    }
+    if (length > 0 && replaceAtPatches.length === length) {
+        return [{ op: "replaceAll", value: nextRows }];
+    }
+    return replaceAtPatches;
+};
+export const areEqual = (a, b) => {
+    // Compare string, number, null ASAP.
+    if (a === b)
+        return true;
+    // Different type works only for string and number, everything else is an object.
+    if (typeof a !== typeof b)
+        return false;
+    // Both are nonnullable objects.
+    if (typeof a === "object" && a !== null && b !== null) {
+        const aIsUint8Array = Predicate.isUint8Array(a);
+        const bIsUint8Array = Predicate.isUint8Array(b);
+        if (aIsUint8Array && bIsUint8Array) {
+            if (a.length !== b.length)
+                return false;
+            for (let i = 0; i < a.length; i++)
+                if (a[i] !== b[i])
+                    return false;
+            return true;
+        }
+        const aIsArray = Array.isArray(a);
+        const bIsArray = Array.isArray(b);
+        if (aIsArray && bIsArray) {
+            if (a.length !== b.length)
+                return false;
+            for (let i = 0; i < a.length; i++)
+                if (!areEqual(a[i], b[i]))
+                    return false;
+            return true;
+        }
+        if (!aIsUint8Array && !bIsUint8Array && !aIsArray && !bIsArray) {
+            const aKeys = Object.keys(a);
+            const bKeys = Object.keys(b);
+            if (aKeys.length !== bKeys.length)
+                return false;
+            for (const key of aKeys)
+                if (!areEqual(a[key], b[key]))
+                    return false;
+            return true;
+        }
+    }
+    return false;
+};

package/dist/src/Errors.d.ts

@@ -0,0 +1,19 @@
+import { Effect } from "effect";
+import { TimestampError } from "./Timestamp.js";
+export type EvoluError = UnexpectedError | TimestampError;
+/**
+ * We can't use the whole error because of WebWorker postMessage DataCloneError
+ * in Safari and Firefox.
+ * https://discord.com/channels/795981131316985866/795983589644304396/1096736473396564079
+ */
+interface TransferableError {
+    readonly message: string;
+    readonly stack: string | undefined;
+}
+export interface UnexpectedError {
+    readonly _tag: "UnexpectedError";
+    readonly error: TransferableError;
+}
+export declare const makeUnexpectedError: (error: unknown) => Effect.Effect<never, UnexpectedError, never>;
+export {};
+//# sourceMappingURL=Errors.d.ts.map

package/dist/src/Errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Errors.d.ts","sourceRoot":"","sources":["../../src/Errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAEhD,MAAM,MAAM,UAAU,GAAG,eAAe,GAAG,cAAc,CAAC;AAE1D;;;;GAIG;AACH,UAAU,iBAAiB;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;CACpC;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAC;CACnC;AAED,eAAO,MAAM,mBAAmB,UACvB,OAAO,KACb,aAAa,CAAC,KAAK,EAAE,eAAe,EAAE,KAAK,CAU7C,CAAC"}

package/dist/src/Errors.js

@@ -0,0 +1,11 @@
+import { Effect } from "effect";
+export const makeUnexpectedError = (error) => {
+    const isError = error instanceof Error;
+    return Effect.fail({
+        _tag: "UnexpectedError",
+        error: {
+            message: isError ? error.message : String(error),
+            stack: isError ? error.stack : undefined,
+        },
+    });
+};

package/dist/src/Evolu.d.ts

@@ -0,0 +1,71 @@
+import { Context, Either, Layer } from "effect";
+import { Simplify } from "kysely";
+import { Config } from "./Config.js";
+import { Bip39, NanoId } from "./Crypto.js";
+import { CommonColumns, CreateQuery, Owner, Schema, Tables } from "./Db.js";
+import { DbWorker, DbWorkerOutputOnQuery } from "./DbWorker.js";
+import { EvoluError } from "./Errors.js";
+import { CastableForMutate } from "./Model.js";
+import { AppState, FlushSync } from "./Platform.js";
+import { Query, Row } from "./Sqlite.js";
+import { Store, StoreListener, StoreUnsubscribe } from "./Store.js";
+import { SyncState } from "./SyncWorker.js";
+import { Time } from "./Timestamp.js";
+export interface Evolu<S extends Schema> {
+    readonly subscribeError: ErrorStore["subscribe"];
+    readonly getError: ErrorStore["getState"];
+    readonly subscribeOwner: OwnerStore["subscribe"];
+    readonly getOwner: OwnerStore["getState"];
+    readonly subscribeQuery: QueryStore["subscribe"];
+    readonly getQuery: QueryStore["getState"];
+    readonly createQuery: CreateQuery<S>;
+    readonly loadQuery: QueryStore["loadQuery"];
+    readonly subscribeSyncState: (listener: StoreListener) => StoreUnsubscribe;
+    readonly getSyncState: () => SyncState;
+    readonly create: Create<S>;
+    readonly update: Update<S>;
+    readonly ownerActions: OwnerActions;
+    readonly ensureSchema: (tables: Tables) => void;
+}
+export declare const Evolu: <T extends Schema>() => Context.Tag<Evolu<T>, Evolu<T>>;
+type ErrorStore = Store<EvoluError | null>;
+type OwnerStore = Store<Owner | null>;
+interface QueryStore {
+    readonly subscribe: (query: Query | null) => (listener: StoreListener) => StoreUnsubscribe;
+    readonly getState: (query: Query | null) => ReadonlyArray<Row> | null;
+    readonly loadQuery: (query: Query) => Promise<ReadonlyArray<Row>>;
+    readonly onQuery: (output: DbWorkerOutputOnQuery) => void;
+}
+declare const QueryStore: Context.Tag<QueryStore, QueryStore>;
+export type Create<S extends Schema> = <T extends keyof S>(table: T, values: Simplify<PartialOnlyForNullable<CastableForMutate<Omit<S[T], "id">>>>, onComplete?: () => void) => {
+    readonly id: S[T]["id"];
+};
+type PartialOnlyForNullable<T, NK extends keyof T = {
+    [K in keyof T]: null extends T[K] ? K : never;
+}[keyof T], NP = Pick<T, Exclude<keyof T, NK>> & Partial<Pick<T, NK>>> = {
+    [K in keyof NP]: NP[K];
+};
+export type Update<S extends Schema> = <T extends keyof S>(table: T, values: Simplify<Partial<CastableForMutate<Omit<S[T], "id"> & Pick<CommonColumns, "isDeleted">>> & {
+    readonly id: S[T]["id"];
+}>, onComplete?: () => void) => {
+    readonly id: S[T]["id"];
+};
+export interface OwnerActions {
+    /**
+     * Use `reset` to delete all local data from the current device.
+     * After the deletion, Evolu reloads all browser tabs that use Evolu.
+     */
+    readonly reset: () => void;
+    /**
+     * Use `restore` to restore `Owner` with synced data on a different device.
+     */
+    readonly restore: (mnemonic: string) => Promise<Either.Either<RestoreOwnerError, void>>;
+}
+interface RestoreOwnerError {
+    readonly _tag: "RestoreOwnerError";
+}
+export declare const loadingPromisesPromiseProp = "rows";
+export declare const EvoluLive: <T extends Schema>(tables: Tables) => Layer.Layer<Config | Bip39 | NanoId | Time | FlushSync | AppState | DbWorker, never, Evolu<T>>;
+export declare const makeEvoluForPlatform: <T extends Schema>(PlatformLayer: Layer.Layer<never, never, DbWorker | Bip39 | NanoId | FlushSync | AppState>, tables: Tables, config?: Partial<Config>) => Evolu<T>;
+export {};
+//# sourceMappingURL=Evolu.d.ts.map

package/dist/src/Evolu.d.ts.map

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