pomegranate-db 0.1.0

package/dist/query/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.query = exports.QueryBuilder = void 0;
+var QueryBuilder_1 = require("./QueryBuilder");
+Object.defineProperty(exports, "QueryBuilder", { enumerable: true, get: function () { return QueryBuilder_1.QueryBuilder; } });
+Object.defineProperty(exports, "query", { enumerable: true, get: function () { return QueryBuilder_1.query; } });
+//# sourceMappingURL=index.js.map

package/dist/query/types.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Query descriptor types.
+ *
+ * Queries are built as plain descriptor objects (no classes), making them
+ * serializable and easy to translate to SQL or LokiJS query syntax.
+ */
+export type ComparisonOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'notIn' | 'like' | 'notLike' | 'between' | 'isNull' | 'isNotNull';
+export interface WhereClause {
+    readonly type: 'where';
+    readonly column: string;
+    readonly operator: ComparisonOperator;
+    readonly value: unknown;
+}
+export interface AndClause {
+    readonly type: 'and';
+    readonly conditions: readonly Condition[];
+}
+export interface OrClause {
+    readonly type: 'or';
+    readonly conditions: readonly Condition[];
+}
+export interface NotClause {
+    readonly type: 'not';
+    readonly condition: Condition;
+}
+export type Condition = WhereClause | AndClause | OrClause | NotClause;
+export type SortOrder = 'asc' | 'desc';
+export interface OrderByClause {
+    readonly column: string;
+    readonly order: SortOrder;
+}
+export interface JoinClause {
+    readonly table: string;
+    readonly leftColumn: string;
+    readonly rightColumn: string;
+}
+export interface QueryDescriptor {
+    readonly table: string;
+    readonly conditions: readonly Condition[];
+    readonly orderBy: readonly OrderByClause[];
+    readonly limit?: number;
+    readonly offset?: number;
+    readonly joins: readonly JoinClause[];
+}
+export interface SearchDescriptor {
+    readonly table: string;
+    readonly term: string;
+    readonly fields: readonly string[];
+    readonly conditions: readonly Condition[];
+    readonly orderBy: readonly OrderByClause[];
+    readonly limit: number;
+    readonly offset: number;
+}
+export type BatchOperationType = 'create' | 'update' | 'delete' | 'destroyPermanently';
+export interface BatchOperation {
+    readonly type: BatchOperationType;
+    readonly table: string;
+    readonly rawRecord?: Record<string, unknown>;
+    readonly id?: string;
+}

package/dist/query/types.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Query descriptor types.
+ *
+ * Queries are built as plain descriptor objects (no classes), making them
+ * serializable and easy to translate to SQL or LokiJS query syntax.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/schema/builder.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Schema builder — the `m` API.
+ *
+ * Provides a fluent, Zod-inspired builder for defining model schemas
+ * with full TypeScript inference.
+ *
+ * Usage:
+ *   const PostSchema = m.model('posts', {
+ *     title: m.text(),
+ *     body: m.text(),
+ *     isPinned: m.boolean().default(false),
+ *     createdAt: m.date('created_at').readonly(),
+ *     author: m.belongsTo('users', { key: 'author_id' }),
+ *     comments: m.hasMany('comments', { foreignKey: 'post_id' }),
+ *   });
+ */
+import type { ColumnDescriptor, TextColumn, NumberColumn, BooleanColumn, DateColumn, BelongsToDescriptor, HasManyDescriptor, ModelSchema, FieldDescriptor } from './types';
+/**
+ * Fluent builder wrapping a ColumnDescriptor.
+ * Each modifier returns a new frozen object (immutable).
+ */
+export declare class ColumnBuilder<C extends ColumnDescriptor> {
+    readonly descriptor: C;
+    constructor(descriptor: C);
+    /** Mark this column as readonly (cannot be set in update patches) */
+    readonly(): ColumnBuilder<C & {
+        readonly isReadonly: true;
+    }>;
+    /** Mark this column as optional (nullable) */
+    optional(): ColumnBuilder<C & {
+        readonly isOptional: true;
+    }>;
+    /** Add a database index on this column */
+    indexed(): ColumnBuilder<C & {
+        readonly isIndexed: true;
+    }>;
+    /** Set a default value for this column */
+    default(value: unknown): ColumnBuilder<C>;
+}
+/**
+ * Public schema builder API — the `m` object.
+ */
+export declare const m: {
+    /** Text (string) column */
+    text(columnName?: string): ColumnBuilder<TextColumn>;
+    /** Numeric column */
+    number(columnName?: string): ColumnBuilder<NumberColumn>;
+    /** Boolean column */
+    boolean(columnName?: string): ColumnBuilder<BooleanColumn>;
+    /** Date column (stored as epoch ms in the database) */
+    date(columnName?: string): ColumnBuilder<DateColumn>;
+    /** Belongs-to relation (many-to-one). Adds a foreign key column. */
+    belongsTo(relatedTable: string, opts: {
+        key: string;
+    }): BelongsToDescriptor;
+    /** Has-many relation (one-to-many). Query-only, no stored column. */
+    hasMany(relatedTable: string, opts: {
+        foreignKey: string;
+    }): HasManyDescriptor;
+    /**
+     * Define a model schema for the given table.
+     *
+     * Resolves all columns and relations, and returns a frozen ModelSchema
+     * that carries full type information.
+     */
+    model<F extends Record<string, ColumnBuilder<ColumnDescriptor> | BelongsToDescriptor | HasManyDescriptor>>(table: string, fields: F): ModelSchema<{ [K in keyof F]: F[K] extends ColumnBuilder<infer D> ? D : F[K] extends FieldDescriptor ? F[K] : never; }>;
+};
+export { ColumnBuilder as _ColumnBuilder };

package/dist/schema/builder.js

@@ -0,0 +1,168 @@
+"use strict";
+/**
+ * Schema builder — the `m` API.
+ *
+ * Provides a fluent, Zod-inspired builder for defining model schemas
+ * with full TypeScript inference.
+ *
+ * Usage:
+ *   const PostSchema = m.model('posts', {
+ *     title: m.text(),
+ *     body: m.text(),
+ *     isPinned: m.boolean().default(false),
+ *     createdAt: m.date('created_at').readonly(),
+ *     author: m.belongsTo('users', { key: 'author_id' }),
+ *     comments: m.hasMany('comments', { foreignKey: 'post_id' }),
+ *   });
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._ColumnBuilder = exports.m = exports.ColumnBuilder = void 0;
+// ─── Column Builder ────────────────────────────────────────────────────────
+/**
+ * Fluent builder wrapping a ColumnDescriptor.
+ * Each modifier returns a new frozen object (immutable).
+ */
+class ColumnBuilder {
+    descriptor;
+    constructor(descriptor) {
+        this.descriptor = descriptor;
+        Object.freeze(this.descriptor);
+    }
+    /** Mark this column as readonly (cannot be set in update patches) */
+    readonly() {
+        return new ColumnBuilder({ ...this.descriptor, isReadonly: true });
+    }
+    /** Mark this column as optional (nullable) */
+    optional() {
+        return new ColumnBuilder({ ...this.descriptor, isOptional: true });
+    }
+    /** Add a database index on this column */
+    indexed() {
+        return new ColumnBuilder({ ...this.descriptor, isIndexed: true });
+    }
+    /** Set a default value for this column */
+    default(value) {
+        return new ColumnBuilder({ ...this.descriptor, defaultValue: value });
+    }
+}
+exports.ColumnBuilder = ColumnBuilder;
+exports._ColumnBuilder = ColumnBuilder;
+// Make ColumnBuilder look like a plain descriptor for schema inference
+// by forwarding the key properties
+function isColumnBuilder(v) {
+    return v instanceof ColumnBuilder;
+}
+// ─── Helper: resolve a field (ColumnBuilder | RelationDescriptor) ──────────
+function resolveField(fieldName, raw) {
+    const desc = isColumnBuilder(raw) ? raw.descriptor : raw;
+    if ('type' in desc) {
+        const col = {
+            fieldName,
+            columnName: desc.columnName ?? fieldName,
+            type: desc.type,
+            isReadonly: desc.isReadonly,
+            isOptional: desc.isOptional,
+            isIndexed: desc.isIndexed,
+            defaultValue: desc.defaultValue,
+        };
+        return { column: col };
+    }
+    if ('kind' in desc) {
+        const rel = {
+            fieldName,
+            kind: desc.kind,
+            relatedTable: desc.relatedTable,
+            foreignKey: desc.foreignKey,
+        };
+        // belongs_to also implies a column for the foreign key
+        if (desc.kind === 'belongs_to') {
+            const col = {
+                fieldName,
+                columnName: desc.foreignKey,
+                type: 'text',
+                isReadonly: false,
+                isOptional: false,
+                isIndexed: true,
+                defaultValue: undefined,
+            };
+            return { column: col, relation: rel };
+        }
+        return { relation: rel };
+    }
+    throw new Error(`Unknown field descriptor for "${fieldName}"`);
+}
+// ─── The `m` namespace ─────────────────────────────────────────────────────
+function makeColumn(type, columnName) {
+    return new ColumnBuilder({
+        type,
+        columnName,
+        isReadonly: false,
+        isOptional: false,
+        isIndexed: false,
+    });
+}
+/**
+ * Public schema builder API — the `m` object.
+ */
+exports.m = {
+    /** Text (string) column */
+    text(columnName) {
+        return makeColumn('text', columnName ?? null);
+    },
+    /** Numeric column */
+    number(columnName) {
+        return makeColumn('number', columnName ?? null);
+    },
+    /** Boolean column */
+    boolean(columnName) {
+        return makeColumn('boolean', columnName ?? null);
+    },
+    /** Date column (stored as epoch ms in the database) */
+    date(columnName) {
+        return makeColumn('date', columnName ?? null);
+    },
+    /** Belongs-to relation (many-to-one). Adds a foreign key column. */
+    belongsTo(relatedTable, opts) {
+        return Object.freeze({
+            kind: 'belongs_to',
+            relatedTable,
+            foreignKey: opts.key,
+        });
+    },
+    /** Has-many relation (one-to-many). Query-only, no stored column. */
+    hasMany(relatedTable, opts) {
+        return Object.freeze({
+            kind: 'has_many',
+            relatedTable,
+            foreignKey: opts.foreignKey,
+        });
+    },
+    /**
+     * Define a model schema for the given table.
+     *
+     * Resolves all columns and relations, and returns a frozen ModelSchema
+     * that carries full type information.
+     */
+    model(table, fields) {
+        const columns = [];
+        const relations = [];
+        const resolvedFields = {};
+        for (const [name, raw] of Object.entries(fields)) {
+            const { column, relation } = resolveField(name, raw);
+            if (column)
+                columns.push(column);
+            if (relation)
+                relations.push(relation);
+            // Store the resolved descriptor
+            resolvedFields[name] = isColumnBuilder(raw) ? raw.descriptor : raw;
+        }
+        const schema = {
+            table,
+            fields: resolvedFields,
+            columns,
+            relations,
+        };
+        return Object.freeze(schema);
+    },
+};
+//# sourceMappingURL=builder.js.map

package/dist/schema/index.d.ts

@@ -0,0 +1,2 @@
+export { m, ColumnBuilder } from './builder';
+export type { ColumnType, ColumnDescriptor, TextColumn, NumberColumn, BooleanColumn, DateColumn, BelongsToDescriptor, HasManyDescriptor, RelationDescriptor, FieldDescriptor, SchemaFields, ModelSchema, ResolvedColumn, ResolvedRelation, DatabaseSchema, TableSchema, TableColumnSchema, SyncStatus, SyncColumns, RawRecord, InferColumnType, InferField, InferCreatePatch, InferUpdatePatch, InferRecord, } from './types';

package/dist/schema/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColumnBuilder = exports.m = void 0;
+var builder_1 = require("./builder");
+Object.defineProperty(exports, "m", { enumerable: true, get: function () { return builder_1.m; } });
+Object.defineProperty(exports, "ColumnBuilder", { enumerable: true, get: function () { return builder_1.ColumnBuilder; } });
+//# sourceMappingURL=index.js.map

package/dist/schema/types.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Core type definitions for the schema system.
+ *
+ * The schema builder produces typed descriptors that the rest of the system
+ * uses to generate SQL, validate patches, and infer TypeScript types.
+ */
+export type ColumnType = 'text' | 'number' | 'boolean' | 'date';
+export interface ColumnDescriptor {
+    readonly type: ColumnType;
+    readonly columnName: string | null;
+    readonly isReadonly: boolean;
+    readonly isOptional: boolean;
+    readonly isIndexed: boolean;
+    readonly defaultValue?: unknown;
+}
+export interface TextColumn extends ColumnDescriptor {
+    readonly type: 'text';
+}
+export interface NumberColumn extends ColumnDescriptor {
+    readonly type: 'number';
+}
+export interface BooleanColumn extends ColumnDescriptor {
+    readonly type: 'boolean';
+}
+export interface DateColumn extends ColumnDescriptor {
+    readonly type: 'date';
+}
+export type RelationType = 'belongs_to' | 'has_many';
+export interface BelongsToDescriptor {
+    readonly kind: 'belongs_to';
+    readonly relatedTable: string;
+    readonly foreignKey: string;
+}
+export interface HasManyDescriptor {
+    readonly kind: 'has_many';
+    readonly relatedTable: string;
+    readonly foreignKey: string;
+}
+export type RelationDescriptor = BelongsToDescriptor | HasManyDescriptor;
+export type FieldDescriptor = ColumnDescriptor | RelationDescriptor;
+/** The raw shape definition passed to `m.model()` */
+export type SchemaFields = Record<string, FieldDescriptor>;
+/** Compiled model schema with table name and resolved columns */
+export interface ModelSchema<F extends SchemaFields = SchemaFields> {
+    readonly table: string;
+    readonly fields: F;
+    readonly columns: ResolvedColumn[];
+    readonly relations: ResolvedRelation[];
+}
+export interface ResolvedColumn {
+    readonly fieldName: string;
+    readonly columnName: string;
+    readonly type: ColumnType;
+    readonly isReadonly: boolean;
+    readonly isOptional: boolean;
+    readonly isIndexed: boolean;
+    readonly defaultValue?: unknown;
+}
+export interface ResolvedRelation {
+    readonly fieldName: string;
+    readonly kind: RelationType;
+    readonly relatedTable: string;
+    readonly foreignKey: string;
+}
+export interface DatabaseSchema {
+    readonly version: number;
+    readonly tables: TableSchema[];
+}
+export interface TableSchema {
+    readonly name: string;
+    readonly columns: TableColumnSchema[];
+}
+export interface TableColumnSchema {
+    readonly name: string;
+    readonly type: ColumnType;
+    readonly isOptional: boolean;
+    readonly isIndexed: boolean;
+}
+/** Infer the runtime TypeScript type from a ColumnDescriptor */
+export type InferColumnType<C extends ColumnDescriptor> = C['type'] extends 'text' ? string : C['type'] extends 'number' ? number : C['type'] extends 'boolean' ? boolean : C['type'] extends 'date' ? Date : never;
+/** For optional columns, make the type T | null */
+type MaybeOptional<C extends ColumnDescriptor, T> = C['isOptional'] extends true ? T | null : T;
+/** Infer column type respecting optionality */
+export type InferField<C extends FieldDescriptor> = C extends ColumnDescriptor ? MaybeOptional<C, InferColumnType<C>> : C extends BelongsToDescriptor ? string : C extends HasManyDescriptor ? never : never;
+/** The record shape inferred from schema fields (writable columns only) */
+export type InferCreatePatch<F extends SchemaFields> = {
+    [K in keyof F as F[K] extends ColumnDescriptor ? F[K]['isReadonly'] extends true ? never : K : F[K] extends BelongsToDescriptor ? K : never]: F[K] extends ColumnDescriptor ? MaybeOptional<F[K], InferColumnType<F[K]>> : F[K] extends BelongsToDescriptor ? string : never;
+};
+/** The record shape for updates — all writable fields optional */
+export type InferUpdatePatch<F extends SchemaFields> = Partial<InferCreatePatch<F>>;
+/** Full record shape (all columns + belongs_to keys) */
+export type InferRecord<F extends SchemaFields> = {
+    readonly id: string;
+} & {
+    readonly [K in keyof F]: InferField<F[K]>;
+};
+export type SyncStatus = 'synced' | 'created' | 'updated' | 'deleted';
+/** Every persisted row carries sync metadata */
+export interface SyncColumns {
+    readonly _status: SyncStatus;
+    readonly _changed: string;
+}
+/** Raw row as stored in the adapter (values are primitives) */
+export interface RawRecord extends SyncColumns {
+    readonly id: string;
+    [column: string]: unknown;
+}
+export {};

package/dist/schema/types.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Core type definitions for the schema system.
+ *
+ * The schema builder produces typed descriptors that the rest of the system
+ * uses to generate SQL, validate patches, and infer TypeScript types.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/sync/index.d.ts

@@ -0,0 +1,2 @@
+export { performSync } from './sync';
+export type { SyncConfig, SyncPullResult, SyncPushPayload, SyncTableChanges, SyncTableChangeSet, SyncState, SyncLog, } from './types';

package/dist/sync/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.performSync = void 0;
+var sync_1 = require("./sync");
+Object.defineProperty(exports, "performSync", { enumerable: true, get: function () { return sync_1.performSync; } });
+//# sourceMappingURL=index.js.map

package/dist/sync/sync.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Sync engine — pull/push protocol compatible with Watermelon backend sync.
+ *
+ * The sync cycle:
+ * 1. Push local changes to the server
+ * 2. Pull remote changes from the server
+ * 3. Apply remote changes locally (in a transaction)
+ * 4. Mark pushed records as synced
+ *
+ * This follows a "push-first" strategy to minimize conflicts:
+ * the server sees our changes before we pull theirs.
+ */
+import type { Database } from '../database/Database';
+import type { SyncConfig } from './types';
+export declare function performSync(db: Database, config: SyncConfig): Promise<void>;

package/dist/sync/sync.js

@@ -0,0 +1,182 @@
+"use strict";
+/**
+ * Sync engine — pull/push protocol compatible with Watermelon backend sync.
+ *
+ * The sync cycle:
+ * 1. Push local changes to the server
+ * 2. Pull remote changes from the server
+ * 3. Apply remote changes locally (in a transaction)
+ * 4. Mark pushed records as synced
+ *
+ * This follows a "push-first" strategy to minimize conflicts:
+ * the server sees our changes before we pull theirs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.performSync = performSync;
+const utils_1 = require("../utils");
+// ─── Last Pulled At Storage ──────────────────────────────────────────────
+const LAST_PULLED_AT_KEY = 'pomegranate_last_pulled_at';
+async function getLastPulledAt(db) {
+    try {
+        // Store in adapter metadata if available, else use in-memory
+        const raw = await db._adapter.findById('__pomegranate_metadata', LAST_PULLED_AT_KEY);
+        if (raw)
+            return Number(raw.value) || null;
+    }
+    catch {
+        // metadata table might not have this record
+    }
+    return null;
+}
+async function setLastPulledAt(db, timestamp) {
+    try {
+        await db._adapter.batch([
+            {
+                type: 'create',
+                table: '__pomegranate_metadata',
+                rawRecord: { id: LAST_PULLED_AT_KEY, key: LAST_PULLED_AT_KEY, value: String(timestamp) },
+            },
+        ]);
+    }
+    catch {
+        // If record exists, update it
+        try {
+            await db._adapter.update('__pomegranate_metadata', {
+                id: LAST_PULLED_AT_KEY,
+                key: LAST_PULLED_AT_KEY,
+                value: String(timestamp),
+                _status: 'synced',
+                _changed: '',
+            });
+        }
+        catch {
+            utils_1.logger.warn('Could not persist lastPulledAt timestamp');
+        }
+    }
+}
+// ─── Sync Implementation ────────────────────────────────────────────────
+async function performSync(db, config) {
+    const tables = config.tables ?? db.tables;
+    const lastPulledAt = await getLastPulledAt(db);
+    utils_1.logger.debug(`Sync starting. lastPulledAt: ${lastPulledAt}`);
+    // ── Step 1: Get local changes ──
+    const localChanges = await db._adapter.getLocalChanges(tables);
+    const hasLocalChanges = Object.values(localChanges).some((tc) => tc.created.length > 0 || tc.updated.length > 0 || tc.deleted.length > 0);
+    // Track which records were locally modified (needed for conflict detection after push)
+    const locallyModifiedIds = new Set();
+    const locallyModifiedRecords = new Map();
+    for (const [_table, tc] of Object.entries(localChanges)) {
+        for (const r of tc.updated) {
+            locallyModifiedIds.add(r.id);
+            locallyModifiedRecords.set(r.id, r);
+        }
+    }
+    // ── Step 2: Push local changes (if any) ──
+    if (hasLocalChanges) {
+        utils_1.logger.debug('Pushing local changes...');
+        // Strip internal sync fields before pushing
+        const pushPayload = sanitizeForPush(localChanges);
+        await config.pushChanges({
+            changes: pushPayload,
+            lastPulledAt: lastPulledAt ?? 0,
+        });
+        // Mark all pushed records as synced
+        for (const table of tables) {
+            const tableChanges = localChanges[table];
+            if (!tableChanges)
+                continue;
+            const syncedIds = [
+                ...tableChanges.created.map((r) => r.id),
+                ...tableChanges.updated.map((r) => r.id),
+            ];
+            if (syncedIds.length > 0) {
+                await db._adapter.markAsSynced(table, syncedIds);
+            }
+            // Permanently remove locally-deleted records that were pushed
+            if (tableChanges.deleted.length > 0) {
+                for (const id of tableChanges.deleted) {
+                    await db._adapter.destroyPermanently(table, id);
+                }
+            }
+        }
+        utils_1.logger.debug('Push complete.');
+    }
+    // ── Step 3: Pull remote changes ──
+    utils_1.logger.debug('Pulling remote changes...');
+    const pullResult = await config.pullChanges({ lastPulledAt });
+    // ── Step 4: Apply remote changes ──
+    const remoteChanges = pullResult.changes;
+    const hasRemoteChanges = Object.values(remoteChanges).some((tc) => tc.created.length > 0 || tc.updated.length > 0 || tc.deleted.length > 0);
+    if (hasRemoteChanges) {
+        utils_1.logger.debug('Applying remote changes...');
+        // Handle conflicts: if a record was modified both locally and remotely
+        if (config.onConflict) {
+            await resolveConflicts(db, remoteChanges, config.onConflict, locallyModifiedIds, locallyModifiedRecords);
+        }
+        await db._adapter.applyRemoteChanges(remoteChanges);
+        // Clear caches for affected collections
+        for (const table of Object.keys(remoteChanges)) {
+            try {
+                const collection = db.collection(table);
+                collection._clearCache();
+            }
+            catch {
+                // Table might not have a registered collection
+            }
+        }
+        utils_1.logger.debug('Remote changes applied.');
+    }
+    // ── Step 5: Update lastPulledAt ──
+    await setLastPulledAt(db, pullResult.timestamp);
+    utils_1.logger.debug(`Sync complete. New lastPulledAt: ${pullResult.timestamp}`);
+}
+// ─── Helpers ────────────────────────────────────────────────────────────
+/**
+ * Remove internal sync columns (_status, _changed) from records
+ * before sending to the server.
+ */
+function sanitizeForPush(changes) {
+    const sanitized = {};
+    for (const [table, tableChanges] of Object.entries(changes)) {
+        sanitized[table] = {
+            created: tableChanges.created.map(stripSyncColumns),
+            updated: tableChanges.updated.map(stripSyncColumns),
+            deleted: tableChanges.deleted,
+        };
+    }
+    return sanitized;
+}
+function stripSyncColumns(raw) {
+    const { _status, _changed, ...rest } = raw;
+    return { ...rest, _status: 'synced', _changed: '' };
+}
+/**
+ * Resolve conflicts between local and remote changes.
+ * Uses locallyModifiedIds (collected before push) to detect records that
+ * were modified locally, since push has already marked them as synced.
+ */
+async function resolveConflicts(db, remoteChanges, onConflict, locallyModifiedIds, locallyModifiedRecords) {
+    for (const [table, tableChanges] of Object.entries(remoteChanges)) {
+        const resolvedUpdates = [];
+        for (const remoteRecord of tableChanges.updated) {
+            // Check if this record was locally modified (before push)
+            if (locallyModifiedIds.has(remoteRecord.id)) {
+                const localRecord = locallyModifiedRecords.get(remoteRecord.id) ??
+                    (await db._adapter.findById(table, remoteRecord.id));
+                if (localRecord) {
+                    // Conflict! Both modified locally and remotely
+                    const resolved = onConflict(localRecord, remoteRecord);
+                    resolvedUpdates.push({ ...resolved, _status: 'synced', _changed: '' });
+                }
+                else {
+                    resolvedUpdates.push(remoteRecord);
+                }
+            }
+            else {
+                resolvedUpdates.push(remoteRecord);
+            }
+        }
+        tableChanges.updated = resolvedUpdates;
+    }
+}
+//# sourceMappingURL=sync.js.map