@sqlite-sync/core 0.6.0 → 0.7.0

package/dist/index.d.ts

@@ -1,9 +1,8 @@
 import * as kysely from 'kysely';
 import { Kysely, SchemaModule } from 'kysely';
-import { S as SQLiteDbWrapper, L as Logger, T as TypedEvent, I as InternalSQLiteWrapper, a as StoredValue, C as CrdtStorage, E as ExecuteParams, b as ExecuteResult, Q as QueryBuilderOutput, K as KyselyQueryFactory, c as SQLiteTransactionWrapper, W as WorkerState, D as DeSyncDetectedReason } from './crdt-sync-remote-source-CJrVzW-B.js';
-export { R as CRDT_EVENT_NO_OP_PAYLOAD, U as CrdtEventOrigin, V as CrdtEventStatus, X as CrdtEventType, F as CrdtSyncRemoteSource, Y as CrdtUpdateLogItem, Z as CrdtUpdateLogPayload, g as DatabaseIntrospection, a5 as DeferredPromise, a6 as DistributiveOmit, J as EventsPullRequest, N as EventsPushRequest, O as EventsPushResponse, H as HLC, f as HLCCounter, a1 as KyselyStatementFactory, j as LogLevel, M as MigratableEvent, n as Migrations, o as MigrationsDb, P as PendingCrdtEvent, $ as PersistedCrdtEvent, a2 as PreparedStatement, p as SyncDbMigrator, w as SystemDbConfig, x as SystemMigration, y as SystemMigrationContext, h as TableMetadata, aa as TypedBroadcastChannel, ab as TypedEventTarget, ae as WorkerConfig, af as WorkerNotificationMessage, q as applyMemoryDbSchema, r as applyWorkerDbSchema, t as baseSystemMigrations, d as compareHLC, z as createCrdtApplyFunction, B as createCrdtStorage, G as createCrdtSyncRemoteSource, a3 as createDeferredPromise, l as createMigrations, m as createMigrator, A as createSQLiteCrdtApplyFunction, a0 as createStoredValue, u as createSystemDbConfig, a4 as createTypedEventTarget, e as deserializeHLC, a7 as generateId, i as introspectDb, _ as isNoOpCrdtEventPayload, a8 as jsonSafeParse, a9 as quoteId, v as runSystemMigrations, s as serializeHLC, k as startPerformanceLogger, ac as tryCatch, ad as tryCatchAsync } from './crdt-sync-remote-source-CJrVzW-B.js';
-import { S as SyncDbSchema, C as CrdtTableConfig } from './reset-state-Comk7IC0.js';
-export { a as CreateCrdtSchemaOptions, R as RESET_REQUEST_TTL_MS, b as ResetRequest, d as ResetStore, c as createSyncDbSchema } from './reset-state-Comk7IC0.js';
+import { S as SQLiteDbWrapper, L as Logger, T as TypedEvent, I as InternalSQLiteWrapper, a as StoredValue, b as SyncSchemaTables, c as SyncDbSchema, A as AnyTableBuilder, d as TableBuilder, e as TableColumns, f as InferRow, R as ReadonlyTable, M as Migrations, N as NewCrdtEvent, C as CrdtStorage, E as ExecuteParams, g as ExecuteResult, Q as QueryBuilderOutput, K as KyselyQueryFactory, h as SQLiteTransactionWrapper, W as WorkerState, D as DeSyncDetectedReason, i as CrdtTableConfig } from './crdt-sync-remote-source-BFl7v5_I.js';
+export { U as AnyColumnBuilder, ab as CRDT_EVENT_NO_OP_PAYLOAD, V as ColumnBuilder, X as ColumnKind, Y as ColumnMeta, m as ColumnMetadata, ac as CrdtEventOrigin, ad as CrdtEventStatus, ae as CrdtEventType, a6 as CrdtSyncRemoteSource, af as CrdtUpdateLogItem, ag as CrdtUpdateLogPayload, n as DatabaseIntrospection, ao as DeferredPromise, ap as DistributiveOmit, a8 as EventsPullRequest, a9 as EventsPushRequest, aa as EventsPushResponse, H as HLC, l as HLCCounter, ak as KyselyStatementFactory, q as LogLevel, v as MigratableEvent, w as MigrationsDb, a5 as OwnCrdtEvent, Z as PayloadValidationResult, a3 as PendingCrdtEvent, ai as PersistedCrdtEvent, al as PreparedStatement, _ as SqliteStorageType, x as SyncDbMigrator, J as SystemDbConfig, O as SystemMigration, P as SystemMigrationContext, p as TableMetadata, $ as TableOptions, at as TypedBroadcastChannel, au as TypedEventTarget, ax as WorkerConfig, ay as WorkerNotificationMessage, y as applyMemoryDbSchema, z as applyWorkerDbSchema, B as baseSystemMigrations, j as compareHLC, a1 as createCrdtApplyFunction, a4 as createCrdtStorage, a7 as createCrdtSyncRemoteSource, am as createDeferredPromise, t as createMigrations, u as createMigrator, a2 as createSQLiteCrdtApplyFunction, aj as createStoredValue, F as createSystemDbConfig, an as createTypedEventTarget, k as deserializeHLC, aq as generateId, o as introspectDb, ah as isNoOpCrdtEventPayload, ar as jsonSafeParse, as as quoteId, G as runSystemMigrations, s as serializeHLC, r as startPerformanceLogger, a0 as t, av as tryCatch, aw as tryCatchAsync } from './crdt-sync-remote-source-BFl7v5_I.js';
+export { R as RESET_REQUEST_TTL_MS, a as ResetRequest, b as ResetStore } from './reset-state-D6UslXaj.js';
 import '@sqlite.org/sqlite-wasm';
 
 declare const dummyKysely: Kysely<any>;
@@ -106,6 +105,72 @@ declare function createSQLiteKvStore({ db, metaTableName }: {
     createNumberStoredValue: (key: string, defaultValue: number) => StoredValue<number>;
 };
 
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type RowOf<Table extends AnyTableBuilder> = Table extends TableBuilder<infer Cols extends TableColumns, any> ? InferRow<Cols> : never;
+type BaseNameOf<CrdtName, Table extends AnyTableBuilder> = string extends Table["~baseName"] ? `_${CrdtName & string}` : [Table["~baseName"]] extends [string] ? Table["~baseName"] : `_${CrdtName & string}`;
+type ClientSchemaOf<Tables extends SyncSchemaTables> = Simplify<{
+    [K in keyof Tables]: RowOf<Tables[K]>;
+} & {
+    [K in keyof Tables as BaseNameOf<K, Tables[K]>]: ReadonlyTable<RowOf<Tables[K]>>;
+}>;
+type ServerSchemaOf<Tables extends SyncSchemaTables> = Simplify<{
+    [K in keyof Tables]: ReadonlyTable<RowOf<Tables[K]>>;
+} & {
+    [K in keyof Tables as BaseNameOf<K, Tables[K]>]: ReadonlyTable<RowOf<Tables[K]>>;
+}>;
+type MutationsSchemaOf<Tables extends SyncSchemaTables> = Simplify<{
+    [K in keyof Tables as BaseNameOf<K, Tables[K]>]: RowOf<Tables[K]>;
+}>;
+interface DefinedSyncSchema<Tables extends SyncSchemaTables> extends SyncDbSchema<ClientSchemaOf<Tables>, ServerSchemaOf<Tables>, MutationsSchemaOf<Tables>> {
+    /** The table builders, for type extraction (`typeof schema.tables.item.$row`) and runtime metadata. */
+    tables: Tables;
+}
+type DefineSyncSchemaConfig<Tables extends SyncSchemaTables> = {
+    tables: Tables;
+    /** Full migration history (including the initial createTable version), built with `createMigrations`. */
+    migrations: Migrations;
+};
+/**
+ * Define a sync database schema from `t.table()` builders.
+ *
+ * Record keys are the crdt (view) table names; base table names default to the key
+ * prefixed with "_", overridable per table via `t.table(cols, { baseName })`.
+ */
+declare function defineSyncSchema<Tables extends SyncSchemaTables>({ tables, migrations, }: DefineSyncSchemaConfig<Tables>): DefinedSyncSchema<Tables>;
+
+type NewCrdtEventValidationResult = {
+    success: true;
+    event: NewCrdtEvent;
+} | {
+    success: false;
+    errors: string[];
+};
+declare class CrdtEventValidationError extends Error {
+    readonly errors: string[];
+    constructor(errors: string[]);
+}
+declare function validateNewCrdtEvent(schema: Pick<SyncDbSchema, "tables" | "tablesConfig">, input: unknown): NewCrdtEventValidationResult;
+
+type SchemaVerificationIssue = {
+    table: string;
+    column?: string;
+    message: string;
+};
+/**
+ * Verify that replaying the full migration history on a fresh database produces
+ * exactly the declared table schema. Creates a throwaway in-memory SQLite db,
+ * applies all migrations, introspects the result, and diffs it against the
+ * `t.table()` declarations.
+ *
+ * Returns an empty array when migrations and schema agree. Intended for dev-time
+ * checks (`startDbWorker({ verifySchema: true })`) and tests:
+ * `expect(await verifySyncSchema(syncDbSchema)).toEqual([])`.
+ */
+declare function verifySyncSchema(schema: SyncDbSchema): Promise<SchemaVerificationIssue[]>;
+declare function formatSchemaVerificationIssues(issues: SchemaVerificationIssue[]): string;
+
 type CrdtStorageMutator<Database> = ReturnType<typeof createCrdtStorageMutator<Database>>;
 type CommitEventOptions<Database, Table extends keyof Database & string> = {
     type: "item-created";
@@ -238,4 +303,4 @@ declare function createSyncedDb<Database, Props = undefined>(options: SyncedDbOp
 }>;
 type SyncedDb<Database> = Awaited<ReturnType<typeof createSyncedDb<Database>>>;
 
-export { CrdtStorage, type CrdtStorageMutator, CrdtTableConfig, ExecuteParams, ExecuteResult, InternalSQLiteWrapper, type KvStoreItem, KyselyQueryFactory, Logger, QueryBuilderOutput, SQLiteDbWrapper, SQLiteReactiveDb, SQLiteTransactionWrapper, type SharedLiveQuery, type SharedLiveQuerySnapshot, StoredValue, SyncDbSchema, type SyncedDb, TypedEvent, WorkerState, createCrdtStorageMutator, createCrdtSyncProducer, createKvStoreTableQuery, createSQLiteKvStore, createSyncedDb, dummyKysely, makeCrdtTable, parametersAreEqual, xxhash };
+export { AnyTableBuilder, CrdtEventValidationError, CrdtStorage, type CrdtStorageMutator, CrdtTableConfig, type DefineSyncSchemaConfig, type DefinedSyncSchema, ExecuteParams, ExecuteResult, InferRow, InternalSQLiteWrapper, type KvStoreItem, KyselyQueryFactory, Logger, Migrations, type NewCrdtEventValidationResult, QueryBuilderOutput, ReadonlyTable, SQLiteDbWrapper, SQLiteReactiveDb, SQLiteTransactionWrapper, type SchemaVerificationIssue, type SharedLiveQuery, type SharedLiveQuerySnapshot, StoredValue, SyncDbSchema, SyncSchemaTables, type SyncedDb, TableBuilder, TableColumns, TypedEvent, WorkerState, createCrdtStorageMutator, createCrdtSyncProducer, createKvStoreTableQuery, createSQLiteKvStore, createSyncedDb, defineSyncSchema, dummyKysely, formatSchemaVerificationIssues, makeCrdtTable, parametersAreEqual, validateNewCrdtEvent, verifySyncSchema, xxhash };

package/dist/index.js

@@ -1,5 +1,6 @@
 import {
   CRDT_EVENT_NO_OP_PAYLOAD,
+  CrdtEventValidationError,
   HLCCounter,
   RESET_REQUEST_TTL_MS,
   SQLiteDbWrapper,
@@ -21,6 +22,7 @@ import {
   createSystemDbConfig,
   deserializeHLC,
   dummyKysely,
+  formatSchemaVerificationIssues,
   introspectDb,
   isNoOpCrdtEventPayload,
   isWorkerErrorResponseMessage,
@@ -31,8 +33,10 @@ import {
   serializeHLC,
   startPerformanceLogger,
   syncDbClientLockName,
+  validateNewCrdtEvent,
+  verifySyncSchema,
   xxhash
-} from "./chunk-3L4QG3BZ.js";
+} from "./chunk-LBYL5L4O.js";
 import {
   TypedBroadcastChannel,
   TypedEvent,
@@ -458,45 +462,202 @@ function parametersAreEqual(a, b) {
   return true;
 }
 
-// src/sqlite-crdt/crdt-schema.ts
-function createSyncDbSchema({ migrations }) {
-  return new CrdtSchemaBuilder({ tables: [], migrations });
+// src/schema/define-sync-schema.ts
+function defineSyncSchema({
+  tables,
+  migrations
+}) {
+  const tablesConfig = Object.entries(tables).map(([crdtTableName, table]) => ({
+    crdtTableName,
+    baseTableName: table.baseName ?? `_${crdtTableName}`
+  }));
+  const seenNames = /* @__PURE__ */ new Set();
+  for (const { crdtTableName, baseTableName } of tablesConfig) {
+    for (const name of [crdtTableName, baseTableName]) {
+      if (seenNames.has(name)) {
+        throw new Error(`Duplicate table name "${name}" in sync schema`);
+      }
+      seenNames.add(name);
+    }
+  }
+  return {
+    tables,
+    get tablesConfig() {
+      return tablesConfig;
+    },
+    get migrations() {
+      return migrations;
+    },
+    get "~clientSchema"() {
+      throw new Error("~clientSchema is type-only and cannot be accessed at runtime");
+    },
+    get "~serverSchema"() {
+      throw new Error("~serverSchema is type-only and cannot be accessed at runtime");
+    },
+    get "~mutationsSchema"() {
+      throw new Error("~mutationsSchema is type-only and cannot be accessed at runtime");
+    }
+  };
 }
-var CrdtSchemaBuilder = class _CrdtSchemaBuilder {
-  constructor(config) {
-    this.config = config;
+
+// src/schema/table-builder.ts
+var ColumnBuilder = class _ColumnBuilder {
+  constructor(meta) {
+    this.meta = meta;
   }
-  get tablesConfig() {
-    return this.config.tables;
+  /** Allow SQL NULL; widens the value type with `null`. */
+  nullable() {
+    return new _ColumnBuilder({ ...this.meta, nullable: true });
   }
-  get migrations() {
-    return this.config.migrations;
+  /** Declare a column default. The value is used both in DDL and when migrating older events. */
+  default(value) {
+    return new _ColumnBuilder({ ...this.meta, hasDefault: true, defaultValue: value });
   }
-  get "~clientSchema"() {
-    console.warn("~clientSchema should not be accessed on the client");
-    return null;
+  /** Narrow the TypeScript value type without changing storage, e.g. `t.text().$type<"movie" | "tv">()`. */
+  $type() {
+    return this;
   }
-  get "~serverSchema"() {
-    console.warn("~serverSchema should not be accessed on the server");
-    return null;
+  /** Human/AI-readable description, surfaced in generated schema docs. */
+  describe(description) {
+    return new _ColumnBuilder({ ...this.meta, description });
   }
-  get "~mutationsSchema"() {
-    console.warn("~mutationsSchema should not be accessed on the client");
+};
+var RESERVED_COLUMNS = ["id", "tombstone"];
+var idColumnMeta = {
+  kind: "text",
+  sqlType: "text",
+  nullable: false,
+  hasDefault: false,
+  description: "Unique immutable item id"
+};
+var tombstoneColumnMeta = {
+  kind: "boolean",
+  sqlType: "integer",
+  nullable: false,
+  hasDefault: true,
+  defaultValue: false,
+  description: "Soft-delete marker"
+};
+var TableBuilder = class _TableBuilder {
+  constructor(userColumns, options) {
+    this.userColumns = userColumns;
+    for (const reserved of RESERVED_COLUMNS) {
+      if (reserved in userColumns) {
+        throw new Error(`Column "${reserved}" is added automatically to every synced table and cannot be declared`);
+      }
+    }
+    this.columns = {
+      id: idColumnMeta,
+      ...Object.fromEntries(Object.entries(userColumns).map(([name, column2]) => [name, column2.meta])),
+      tombstone: tombstoneColumnMeta
+    };
+    this.baseName = options?.baseName;
+    this.description = options?.description;
+  }
+  /** All columns in DDL order, including the auto-injected `id` and `tombstone`. */
+  columns;
+  baseName;
+  description;
+  describe(description) {
+    return new _TableBuilder(this.userColumns, { baseName: this.baseName, description });
+  }
+  /** Type-only: the row shape returned by queries. Do not access at runtime. */
+  get $row() {
     return null;
   }
-  addTable() {
-    const withConfig = ({
-      baseTableName,
-      crdtTableName
-    }) => {
-      this.config.tables.push({ baseTableName, crdtTableName });
-      return new _CrdtSchemaBuilder(this.config);
-    };
-    return { withConfig };
+  /**
+   * Validate a CRDT event payload against the declared columns.
+   * `item-created` payloads must contain every column without a default (nullable columns may be omitted);
+   * `item-updated` payloads are partial and must not touch `id` or set `tombstone` to a deleted value.
+   */
+  validatePayload(payload, options) {
+    const event = options?.event ?? "item-created";
+    const errors = [];
+    for (const key of Object.keys(payload)) {
+      if (!(key in this.columns)) {
+        errors.push(`Unknown column "${key}"`);
+      }
+    }
+    if (event === "item-updated") {
+      if ("id" in payload) {
+        errors.push(`Column "id" is immutable and cannot appear in an update payload`);
+      }
+      if (payload.tombstone === true || payload.tombstone === 1) {
+        errors.push(`Column "tombstone" cannot be set to true/1 in an update payload; use an item-deleted event`);
+      }
+    }
+    if (event === "item-created") {
+      for (const [name, meta] of Object.entries(this.columns)) {
+        if (name in payload || name === "tombstone" || meta.nullable || meta.hasDefault) {
+          continue;
+        }
+        errors.push(`Missing required column "${name}"`);
+      }
+    }
+    for (const [name, value] of Object.entries(payload)) {
+      const meta = this.columns[name];
+      if (!meta || event === "item-updated" && name === "id") {
+        continue;
+      }
+      const error = validateValue(name, value, meta);
+      if (error) {
+        errors.push(error);
+      }
+    }
+    return errors.length === 0 ? { success: true } : { success: false, errors };
   }
-  build() {
-    return this;
+};
+function describeValue(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+function validateValue(name, value, meta) {
+  if (value === null) {
+    return meta.nullable ? null : `Column "${name}" is not nullable, got null`;
   }
+  switch (meta.kind) {
+    case "text":
+      return typeof value === "string" ? null : `Column "${name}" expects text, got ${describeValue(value)}`;
+    case "integer":
+      return typeof value === "number" && Number.isInteger(value) ? null : `Column "${name}" expects an integer, got ${describeValue(value)}`;
+    case "real":
+      return typeof value === "number" && Number.isFinite(value) ? null : `Column "${name}" expects a number, got ${describeValue(value)}`;
+    case "boolean":
+      return typeof value === "boolean" || value === 0 || value === 1 ? null : `Column "${name}" expects a boolean (true/false or 0/1), got ${describeValue(value)}`;
+    case "enum": {
+      if (typeof value !== "string") {
+        return `Column "${name}" expects one of ${formatEnumValues(meta)}, got ${describeValue(value)}`;
+      }
+      return meta.enumValues?.includes(value) ? null : `Column "${name}" expects one of ${formatEnumValues(meta)}, got "${value}"`;
+    }
+  }
+}
+function formatEnumValues(meta) {
+  return (meta.enumValues ?? []).map((value) => `"${value}"`).join(" | ");
+}
+function column(kind, sqlType) {
+  return new ColumnBuilder({ kind, sqlType, nullable: false, hasDefault: false });
+}
+var t = {
+  text: () => column("text", "text"),
+  integer: () => column("integer", "integer"),
+  real: () => column("real", "real"),
+  /** Stored as INTEGER 0/1; always bind booleans as 0/1 when writing raw SQL. */
+  boolean: () => column("boolean", "integer"),
+  /**
+   * Union of string literals stored as TEXT, e.g. `t.enum(["movie", "tv"])`. Unlike `$type`, the
+   * allowed values are kept as runtime metadata, so payloads are validated against them.
+   * For an open-ended set, use `t.text().$type<"idle" | (string & {})>()` instead.
+   */
+  enum: (values) => new ColumnBuilder({
+    kind: "enum",
+    sqlType: "text",
+    nullable: false,
+    hasDefault: false,
+    enumValues: values
+  }),
+  table: (columns, options) => new TableBuilder(columns, options)
 };
 
 // src/sqlite-crdt/crdt-storage-mutator.ts
@@ -583,7 +744,7 @@ select * from ${quoteId(baseTableName)}
 where tombstone = 0;`,
     { loggerLevel: "system" }
   );
-  const allColumnNames = tableSchema.columns.map((column) => column.name);
+  const allColumnNames = tableSchema.columns.map((column2) => column2.name);
   const jsonPayload = (from) => `'{'||${allColumnNames.map((col) => `'"${col}":'||json_quote(${from}.${quoteId(col)})`).join("||','||")}||'}'`;
   db.execute(
     `
@@ -636,17 +797,12 @@ function registerCrdtFunctions({
     innocuous: false,
     callback: (dataset, payloadRaw) => {
       const payload = JSON.parse(payloadRaw);
-      storage.applyOwnEvent(
-        {
-          type: "item-created",
-          dataset,
-          item_id: payload.id,
-          payload: payloadRaw
-        },
-        {
-          wrapInTransaction: false
-        }
-      );
+      storage.internal.applyOwnEventFromTransaction(reactiveDb.db, {
+        type: "item-created",
+        dataset,
+        item_id: payload.id,
+        payload: payloadRaw
+      });
       eventApplied = true;
       return void 0;
     }
@@ -668,34 +824,29 @@ function registerCrdtFunctions({
       const newPayload = JSON.parse(newPayloadRaw);
       let hasDiff = false;
       const updatePayload = {};
-      for (const column of tableSchema.columns) {
-        const oldValue = oldPayload[column.name];
-        const newValue = newPayload[column.name];
+      for (const column2 of tableSchema.columns) {
+        const oldValue = oldPayload[column2.name];
+        const newValue = newPayload[column2.name];
         if (oldValue === newValue) {
           continue;
         }
-        if (column.name === "id") {
+        if (column2.name === "id") {
           throw new Error(
             `Cannot update the "id" column of an item. It is used to identify the item and must be immutable.`
           );
         }
         hasDiff = true;
-        updatePayload[column.name] = newValue;
+        updatePayload[column2.name] = newValue;
       }
       if (!hasDiff) {
         return;
       }
-      storage.applyOwnEvent(
-        {
-          type: "item-updated",
-          dataset,
-          item_id: oldPayload.id,
-          payload: JSON.stringify(updatePayload)
-        },
-        {
-          wrapInTransaction: false
-        }
-      );
+      storage.internal.applyOwnEventFromTransaction(reactiveDb.db, {
+        type: "item-updated",
+        dataset,
+        item_id: oldPayload.id,
+        payload: JSON.stringify(updatePayload)
+      });
       eventApplied = true;
       return void 0;
     }
@@ -706,17 +857,12 @@ function registerCrdtFunctions({
     directOnly: false,
     innocuous: false,
     callback: (dataset, itemId) => {
-      storage.applyOwnEvent(
-        {
-          type: "item-deleted",
-          dataset,
-          item_id: itemId,
-          payload: "{}"
-        },
-        {
-          wrapInTransaction: false
-        }
-      );
+      storage.internal.applyOwnEventFromTransaction(reactiveDb.db, {
+        type: "item-deleted",
+        dataset,
+        item_id: itemId,
+        payload: "{}"
+      });
       eventApplied = true;
       return void 0;
     }
@@ -724,7 +870,7 @@ function registerCrdtFunctions({
   reactiveDb.addEventListener("transaction-committed", () => {
     if (eventApplied) {
       eventApplied = false;
-      storage.dispatchEventsApplied();
+      void storage.internal.processEnqueuedEvents();
     }
   });
   reactiveDb.addEventListener("transaction-rolled-back", () => {
@@ -799,7 +945,8 @@ async function createMemoryDb({
   crdtTables,
   initializeSchema = true,
   initialSyncId,
-  eventHlcAccumulator
+  eventHlcAccumulator,
+  syncDbSchema
 }) {
   await xxhash.ensureLoaded();
   const reactiveDb = _reactiveDb;
@@ -821,7 +968,8 @@ async function createMemoryDb({
     migrator,
     db,
     dbConfig: memoryDbConfig,
-    eventHlcAccumulator
+    eventHlcAccumulator,
+    schema: syncDbSchema
   });
   registerCrdtFunctions({
     reactiveDb,
@@ -1004,7 +1152,8 @@ async function createSyncedDb(options) {
     migrator: memoryDbMigrator,
     reactiveDb,
     hlcCounter,
-    crdtTables: options.syncDbSchema.tablesConfig
+    crdtTables: options.syncDbSchema.tablesConfig,
+    syncDbSchema: options.syncDbSchema
   });
   const pullSyncId = createStoredValue({
     initialValue: workerClientSnapshot.syncId
@@ -1105,10 +1254,13 @@ async function createSyncedDb(options) {
 }
 export {
   CRDT_EVENT_NO_OP_PAYLOAD,
+  ColumnBuilder,
+  CrdtEventValidationError,
   HLCCounter,
   RESET_REQUEST_TTL_MS,
   SQLiteDbWrapper,
   SQLiteReactiveDb,
+  TableBuilder,
   TypedBroadcastChannel,
   TypedEvent,
   applyMemoryDbSchema,
@@ -1127,12 +1279,13 @@ export {
   createSQLiteCrdtApplyFunction,
   createSQLiteKvStore,
   createStoredValue,
-  createSyncDbSchema,
   createSyncedDb,
   createSystemDbConfig,
   createTypedEventTarget,
+  defineSyncSchema,
   deserializeHLC,
   dummyKysely,
+  formatSchemaVerificationIssues,
   generateId,
   introspectDb,
   isNoOpCrdtEventPayload,
@@ -1143,8 +1296,11 @@ export {
   runSystemMigrations,
   serializeHLC,
   startPerformanceLogger,
+  t,
   tryCatch,
   tryCatchAsync,
+  validateNewCrdtEvent,
+  verifySyncSchema,
   xxhash
 };
 //# sourceMappingURL=index.js.map