@abloatai/ablo 0.35.0 → 0.37.0

package/dist/sync/schemas.js

@@ -1,94 +0,0 @@
-/**
- * Zod validation schemas for sync engine server responses.
- *
- * Validates data at the fetch boundary before it enters the sync engine.
- * Unknown keys are kept, so a server that adds a field does not break a client
- * that predates it.
- */
-import { z } from 'zod';
-import { getContext } from "../context.js";
-import { AbloValidationError } from "../transaction/errors.js";
-import { syncDeltaWireCoreSchema } from '../transaction/wire/delta.js';
-// ─── Server Delta Schema ─────────────────────────────────────────────────────
-/**
- * A delta as it arrives in a bootstrap payload.
- *
- * The bootstrap routes return the same rows the broadcast path does, so the
- * fields are taken from {@link syncDeltaWireCoreSchema} rather than restated
- * here — a delta is one shape, and this is the reader for it, not a second
- * definition of it. Unknown keys are kept, because the server sends its own
- * wider projection (attribution, `projectId`) that later stages may read.
- */
-export const ServerDeltaSchema = syncDeltaWireCoreSchema
-    .pick({
-    id: true,
-    actionType: true,
-    modelName: true,
-    modelId: true,
-    data: true,
-})
-    .loose();
-// ─── Model Value Schema ─────────────────────────────────────────────────────
-// A model's values can arrive in more than one shape depending on how the
-// server serialized them:
-//   - Array: an already-parsed JSON array (the common case)
-//   - String: a JSON array still encoded as a string, which must be parsed
-//   - null: no matching rows
-// This schema normalizes every variant into an array before downstream use.
-const ModelValueSchema = z
-    .union([z.array(z.unknown()), z.string(), z.null()])
-    .transform((val) => {
-    if (val === null)
-        return [];
-    if (typeof val === 'string') {
-        try {
-            const parsed = JSON.parse(val);
-            return Array.isArray(parsed) ? parsed : [];
-        }
-        catch {
-            return [];
-        }
-    }
-    return val;
-});
-// ─── Bootstrap Response Schema ───────────────────────────────────────────────
-export const BootstrapResponseSchema = z
-    .object({
-    type: z.enum(['full', 'partial']),
-    lastSyncId: z.number(),
-    models: z.record(z.string(), ModelValueSchema).optional(),
-    deltas: z.array(ServerDeltaSchema).optional(),
-    deltaCount: z.number().optional(),
-    failedModels: z.array(z.string()).optional(),
-    timestamp: z.number().default(() => Date.now()),
-    // The server's active schema hash, used to detect schema drift. Optional:
-    // absent when the server predates this field or the tenant has never
-    // pushed a schema.
-    schemaHash: z.string().optional(),
-    // Present when a paged single-model request stopped at its row limit
-    // with rows remaining: pass it back as the next page's cursor. Absent
-    // on the final page, on unpaged responses, and from older servers.
-    nextCursor: z.string().optional(),
-})
-    .loose();
-// ─── Parse Helpers ───────────────────────────────────────────────────────────
-/**
- * Validates a raw bootstrap response from the server and returns the typed
- * result. On failure it records a diagnostic breadcrumb and throws an
- * {@link AbloValidationError} describing which fields were invalid.
- */
-export function parseBootstrapResponse(raw) {
-    const result = BootstrapResponseSchema.safeParse(raw);
-    if (!result.success) {
-        const issues = result.error.issues.map((i) => `${i.path.join('.')}: ${i.message}`).join('; ');
-        getContext().observability.breadcrumb('Bootstrap response validation failed', 'sync.bootstrap', 'error', {
-            issues,
-            rawType: typeof raw,
-            rawKeys: raw && typeof raw === 'object' ? Object.keys(raw).join(',') : 'n/a',
-        });
-        throw new AbloValidationError(`Invalid bootstrap response: ${issues}`, {
-            code: 'bootstrap_response_schema_invalid',
-        });
-    }
-    return result.data;
-}

package/dist/sync/syncCursor.d.ts

@@ -1,40 +0,0 @@
-/**
- * Holds the resume state of one WebSocket sync session: the `lastSyncId`
- * watermark, which marks the highest delta the client has seen, and an opaque
- * server cursor used for incremental sync. The transport carries both across
- * reconnects so the session can resume where it left off.
- *
- * The watermark advances under a strict rule — it moves forward only on an
- * acknowledgement that is gated on durable persistence — which the transport
- * enforces at its acknowledgement and delta-handling call sites.
- */
-export declare class SyncCursor {
-    lastSyncId: number;
-    syncCursor: string | null;
-    constructor(lastSyncId: number);
-    /**
-     * Advances the watermark in response to an acknowledgement. This becomes the
-     * value the next incremental-sync request and the connect handshake send, and
-     * the value {@link SyncCursor.getLastSyncId} reports when persisting on a
-     * clean shutdown. The move is monotonic: a stale, lower acknowledgement never
-     * pulls the watermark backward.
-     */
-    ackAdvance(syncId: number): void;
-    /**
-     * Sets the watermark outright, used when restoring persisted state.
-     */
-    setLastSyncId(syncId: number): void;
-    /**
-     * Sets the opaque server cursor used for incremental sync.
-     */
-    setSyncCursor(cursor: string | null): void;
-    /**
-     * Returns the current opaque server cursor, or null if none is set.
-     */
-    getSyncCursor(): string | null;
-    /**
-     * Returns the highest delta id seen this session, for persistence on a clean
-     * shutdown.
-     */
-    getLastSyncId(): number;
-}

package/dist/sync/syncCursor.js

@@ -1,55 +0,0 @@
-/**
- * Holds the resume state of one WebSocket sync session: the `lastSyncId`
- * watermark, which marks the highest delta the client has seen, and an opaque
- * server cursor used for incremental sync. The transport carries both across
- * reconnects so the session can resume where it left off.
- *
- * The watermark advances under a strict rule — it moves forward only on an
- * acknowledgement that is gated on durable persistence — which the transport
- * enforces at its acknowledgement and delta-handling call sites.
- */
-export class SyncCursor {
-    lastSyncId;
-    syncCursor;
-    constructor(lastSyncId) {
-        this.lastSyncId = lastSyncId;
-        this.syncCursor = null;
-    }
-    /**
-     * Advances the watermark in response to an acknowledgement. This becomes the
-     * value the next incremental-sync request and the connect handshake send, and
-     * the value {@link SyncCursor.getLastSyncId} reports when persisting on a
-     * clean shutdown. The move is monotonic: a stale, lower acknowledgement never
-     * pulls the watermark backward.
-     */
-    ackAdvance(syncId) {
-        if (syncId > this.lastSyncId) {
-            this.lastSyncId = syncId;
-        }
-    }
-    /**
-     * Sets the watermark outright, used when restoring persisted state.
-     */
-    setLastSyncId(syncId) {
-        this.lastSyncId = syncId;
-    }
-    /**
-     * Sets the opaque server cursor used for incremental sync.
-     */
-    setSyncCursor(cursor) {
-        this.syncCursor = cursor;
-    }
-    /**
-     * Returns the current opaque server cursor, or null if none is set.
-     */
-    getSyncCursor() {
-        return this.syncCursor;
-    }
-    /**
-     * Returns the highest delta id seen this session, for persistence on a clean
-     * shutdown.
-     */
-    getLastSyncId() {
-        return this.lastSyncId || 0;
-    }
-}

package/dist/sync/syncPlan.d.ts

@@ -1,54 +0,0 @@
-/**
- * Derives a client's sync plan from its {@link Schema}. Walking the schema's
- * models and relations, it produces two declarative arrays consumed when the
- * store is constructed: the foreign-key indexes to register on the in-memory
- * object pool, and the enrichment rules that attach related parents to
- * incoming rows. See {@link deriveSyncPlanFromSchema}.
- */
-import type { Schema } from '../transaction/schema/schema.js';
-/** A foreign-key index to register on the in-memory object pool when the store is constructed. */
-export interface ForeignKeyIndexSpec {
-    /**
-     * The name of the child model, where the foreign-key field lives, and the
-     * name the object pool indexes by. Use the wire type-name casing (for
-     * example `'Block'`, not `'block'`), since that is the value
-     * stamped onto reconstructed models and the key the pool looks up.
-     */
-    readonly modelName: string;
-    /** The foreign-key field name on the child model, for example `'sectionId'`. */
-    readonly fieldName: string;
-}
-/**
- * A declarative rule for enriching an incoming row with its related parent.
- *
- * When a delta for `modelName` arrives and its row has been constructed, the
- * store reads the row's `foreignKey` value, looks up the matching parent in
- * the object pool, and attaches it under `relationKey`. Enrichment is
- * best-effort: if the parent is not in the pool yet — for example, it arrives
- * later in the same bootstrap batch — the step is skipped without error.
- */
-export interface EnrichmentPlanEntry {
-    /** The child model whose incoming deltas should be enriched. */
-    readonly modelName: string;
-    /** The foreign-key field on the child that points at the parent's id. */
-    readonly foreignKey: string;
-    /** The property name under which to attach the parent model. */
-    readonly relationKey: string;
-}
-/**
- * Walks a schema and derives the two sync-plan arrays used when the store is
- * constructed: the foreign-key indexes to register on the object pool and the
- * enrichment plan. See {@link ForeignKeyIndexSpec} and
- * {@link EnrichmentPlanEntry}.
- *
- * Both are drawn from each `belongsTo` relation that sets `options.index` or
- * `options.enrich`; relations without those options are skipped. Enabling them
- * is opt-in, so adding a `belongsTo` relation never silently changes how deltas
- * apply or how lookups resolve. A `hasMany` or `hasOne` relation registers its
- * index on the target model, since that is where the foreign key lives. The
- * function has no side effects and is called once at construction.
- */
-export declare function deriveSyncPlanFromSchema(schema: Schema): {
-    enrichmentPlan: EnrichmentPlanEntry[];
-    foreignKeyIndexes: ForeignKeyIndexSpec[];
-};

package/dist/sync/syncPlan.js

@@ -1,50 +0,0 @@
-/**
- * Derives a client's sync plan from its {@link Schema}. Walking the schema's
- * models and relations, it produces two declarative arrays consumed when the
- * store is constructed: the foreign-key indexes to register on the in-memory
- * object pool, and the enrichment rules that attach related parents to
- * incoming rows. See {@link deriveSyncPlanFromSchema}.
- */
-/**
- * Walks a schema and derives the two sync-plan arrays used when the store is
- * constructed: the foreign-key indexes to register on the object pool and the
- * enrichment plan. See {@link ForeignKeyIndexSpec} and
- * {@link EnrichmentPlanEntry}.
- *
- * Both are drawn from each `belongsTo` relation that sets `options.index` or
- * `options.enrich`; relations without those options are skipped. Enabling them
- * is opt-in, so adding a `belongsTo` relation never silently changes how deltas
- * apply or how lookups resolve. A `hasMany` or `hasOne` relation registers its
- * index on the target model, since that is where the foreign key lives. The
- * function has no side effects and is called once at construction.
- */
-export function deriveSyncPlanFromSchema(schema) {
-    const enrichmentPlan = [];
-    const foreignKeyIndexes = [];
-    for (const [modelName, def] of Object.entries(schema.models)) {
-        const typename = def.typename ?? modelName;
-        for (const [relationKey, rel] of Object.entries(def.relations)) {
-            if (rel.type === 'belongsTo') {
-                if (rel.options?.index) {
-                    foreignKeyIndexes.push({ modelName: typename, fieldName: rel.foreignKey });
-                }
-                if (rel.options?.enrich) {
-                    enrichmentPlan.push({
-                        modelName: typename,
-                        foreignKey: rel.foreignKey,
-                        relationKey,
-                    });
-                }
-            }
-            else if (rel.type === 'hasMany' || rel.type === 'hasOne') {
-                // For hasMany and hasOne, the foreign key lives on the target model,
-                // not the current one, so register the index on the target. Its wire
-                // type name is resolved from the schema here.
-                const targetDef = schema.models[rel.target];
-                const targetTypename = targetDef?.typename ?? rel.target;
-                foreignKeyIndexes.push({ modelName: targetTypename, fieldName: rel.foreignKey });
-            }
-        }
-    }
-    return { enrichmentPlan, foreignKeyIndexes };
-}

package/dist/sync/wsFrameHandlers.d.ts

@@ -1,8 +0,0 @@
-/**
- * Moved to the settlement core with the duplex transport (ADR 0016): the
- * inbound frame dispatch is the receiving half of the wire protocol, and the
- * handlers already worked against the minimal `WsSession` port rather than
- * the transport object. This path re-exports it so existing importers stay
- * unchanged.
- */
-export { isRecord, readWsInboundFrame, wsFrameHandlers, dispatchWsFrame, type PendingCommit, type PendingClaim, type PendingSubscription, type WsInboundFrame, type WsSession, type WsFrameHandler, } from '../transaction/transport/wsFrameHandlers.js';

package/dist/sync/wsFrameHandlers.js

@@ -1,8 +0,0 @@
-/**
- * Moved to the settlement core with the duplex transport (ADR 0016): the
- * inbound frame dispatch is the receiving half of the wire protocol, and the
- * handlers already worked against the minimal `WsSession` port rather than
- * the transport object. This path re-exports it so existing importers stay
- * unchanged.
- */
-export { isRecord, readWsInboundFrame, wsFrameHandlers, dispatchWsFrame, } from '../transaction/transport/wsFrameHandlers.js';

package/dist/testing/fixtures/bootstrap.d.ts

@@ -1,49 +0,0 @@
-/**
- * Factories that build well-formed bootstrap responses for tests. A
- * bootstrap response is what the server returns when a client first syncs:
- * either a full snapshot of the models or a partial batch of deltas since a
- * known point. These helpers produce the same shapes, so tests can exercise
- * client sync logic without a live server.
- */
-import type { BootstrapType } from '../../transaction/types/index.js';
-export type BootstrapModelData = Record<string, Record<string, unknown>[]>;
-export interface BootstrapResponse {
-    type: BootstrapType;
-    lastSyncId: number;
-    models?: BootstrapModelData;
-    deltas?: {
-        id: number;
-        modelName: string;
-        modelId: string;
-        action: string;
-        data: Record<string, unknown>;
-    }[];
-    deltaCount?: number;
-    failedModels?: string[];
-    timestamp: number;
-}
-/**
- * Builds a full bootstrap response — a fresh snapshot of the given models,
- * as the server sends on a client's first sync.
- */
-export declare function createFullBootstrapResponse(models: BootstrapModelData, lastSyncId?: number): BootstrapResponse;
-/**
- * Builds a partial bootstrap response — a batch of deltas applied on top of
- * the client's last known sync point, given by `lastSyncId`.
- */
-export declare function createPartialBootstrapResponse(deltas: BootstrapResponse['deltas'], lastSyncId: number): BootstrapResponse;
-/**
- * Builds a full bootstrap response with the common test models
- * pre-populated. Pass any of the named model arrays to include them in the
- * snapshot.
- */
-export declare function createTestBootstrapResponse(options?: {
-    tasks?: Record<string, unknown>[];
-    projects?: Record<string, unknown>[];
-    slideDecks?: Record<string, unknown>[];
-    slides?: Record<string, unknown>[];
-    slideLayers?: Record<string, unknown>[];
-    comments?: Record<string, unknown>[];
-    lastSyncId?: number;
-    failedModels?: string[];
-}): BootstrapResponse;

package/dist/testing/fixtures/bootstrap.js

@@ -1,59 +0,0 @@
-/**
- * Factories that build well-formed bootstrap responses for tests. A
- * bootstrap response is what the server returns when a client first syncs:
- * either a full snapshot of the models or a partial batch of deltas since a
- * known point. These helpers produce the same shapes, so tests can exercise
- * client sync logic without a live server.
- */
-/**
- * Builds a full bootstrap response — a fresh snapshot of the given models,
- * as the server sends on a client's first sync.
- */
-export function createFullBootstrapResponse(models, lastSyncId = 100) {
-    return {
-        type: 'full',
-        lastSyncId,
-        models,
-        timestamp: Date.now(),
-    };
-}
-/**
- * Builds a partial bootstrap response — a batch of deltas applied on top of
- * the client's last known sync point, given by `lastSyncId`.
- */
-export function createPartialBootstrapResponse(deltas, lastSyncId) {
-    return {
-        type: 'partial',
-        lastSyncId,
-        deltas,
-        deltaCount: deltas?.length ?? 0,
-        timestamp: Date.now(),
-    };
-}
-/**
- * Builds a full bootstrap response with the common test models
- * pre-populated. Pass any of the named model arrays to include them in the
- * snapshot.
- */
-export function createTestBootstrapResponse(options = {}) {
-    const models = {};
-    if (options.tasks)
-        models.Task = options.tasks;
-    if (options.projects)
-        models.Project = options.projects;
-    if (options.slideDecks)
-        models.SlideDeck = options.slideDecks;
-    if (options.slides)
-        models.Slide = options.slides;
-    if (options.slideLayers)
-        models.SlideLayer = options.slideLayers;
-    if (options.comments)
-        models.Comment = options.comments;
-    return {
-        type: 'full',
-        lastSyncId: options.lastSyncId ?? 100,
-        models,
-        failedModels: options.failedModels,
-        timestamp: Date.now(),
-    };
-}

package/dist/testing/fixtures/deltas.d.ts

@@ -1,83 +0,0 @@
-/**
- * Factories that build well-formed delta objects for tests. A delta, a
- * {@link SyncAction}, is a single change to one model instance in the wire
- * format the server sends: an insert, update, delete, archive, and so on.
- * These helpers let tests construct deltas without a live server.
- */
-import type { SyncActionType, SyncAction } from '../../stores/syncAction.js';
-/** Reset the delta counter (call in beforeEach for deterministic IDs) */
-export declare function resetDeltaCounter(): void;
-export interface CreateDeltaOptions {
-    /** Sync ID (auto-increments if not provided) */
-    id?: number;
-    /** Model name (e.g., 'Task', 'Slide') */
-    modelName: string;
-    /** Model ID */
-    modelId: string;
-    /** Action type: I=Insert, U=Update, D=Delete, A=Archive, V=Unarchive */
-    action: SyncActionType;
-    /** Delta payload data */
-    data?: Record<string, unknown>;
-}
-/**
- * Builds a single delta ({@link SyncAction}) in the server's wire format.
- */
-export declare function createDelta(options: CreateDeltaOptions): SyncAction;
-/**
- * Builds an insert delta for a new entity.
- */
-export declare function createInsertDelta(modelName: string, modelId: string, data: Record<string, unknown>, syncId?: number): SyncAction;
-/**
- * Builds an update delta for an existing entity.
- */
-export declare function createUpdateDelta(modelName: string, modelId: string, data: Record<string, unknown>, syncId?: number): SyncAction;
-/**
- * Builds a delete delta.
- */
-export declare function createDeleteDelta(modelName: string, modelId: string, syncId?: number): SyncAction;
-/**
- * Builds an archive delta, stamping `archivedAt` with the current time.
- */
-export declare function createArchiveDelta(modelName: string, modelId: string, syncId?: number): SyncAction;
-/**
- * Builds an unarchive delta, clearing `archivedAt`.
- */
-export declare function createUnarchiveDelta(modelName: string, modelId: string, syncId?: number): SyncAction;
-/**
- * Builds a covering ('C') delta. It signals that the client has gained
- * permission to see an entity that already exists. The client treats it
- * like an insert, adding the entity to its local store as if newly created.
- * A covering delta typically follows a group-added delta.
- */
-export declare function createCoveringDelta(modelName: string, modelId: string, data: Record<string, unknown>, syncId?: number): SyncAction;
-/**
- * Builds a group-added ('G') delta in the incremental payload shape. It
- * signals that the recipient was added to a single sync group. The client
- * updates its subscription state and waits for covering deltas to deliver
- * the newly visible entities. Unlike the older payload that carries both
- * added and removed groups, this shape does not trigger a re-bootstrap.
- */
-export declare function createGroupAddedDelta(userId: string, group: string, syncId?: number): SyncAction;
-/**
- * Builds a group-change ('G') delta in the older payload shape, which
- * carries both added and removed groups in one delta and forces a full
- * re-bootstrap on the client. Useful for testing backward compatibility
- * with that older shape.
- */
-export declare function createLegacyGroupChangeDelta(userId: string, added: string[], removed: string[], syncId?: number): SyncAction;
-/**
- * Builds a group-removed ('S') delta. It signals that the recipient lost
- * access to a sync group. The client purges the affected local state and
- * re-bootstraps with the updated group list.
- */
-export declare function createGroupRemovedDelta(userId: string, group: string, syncId?: number): SyncAction;
-/**
- * Builds a batch of deltas with sequential sync IDs.
- */
-export declare function createDeltaBatch(deltas: Omit<CreateDeltaOptions, 'id'>[], startingSyncId?: number): SyncAction[];
-/**
- * Builds a confirmation delta, which signals that a mutation was persisted
- * by the server. The client's transaction queue watches for these to
- * confirm its in-flight writes.
- */
-export declare function createConfirmationDelta(modelName: string, modelId: string, syncId: number, action?: SyncActionType, data?: Record<string, unknown>): SyncAction;

package/dist/testing/fixtures/deltas.js

@@ -1,136 +0,0 @@
-/**
- * Factories that build well-formed delta objects for tests. A delta, a
- * {@link SyncAction}, is a single change to one model instance in the wire
- * format the server sends: an insert, update, delete, archive, and so on.
- * These helpers let tests construct deltas without a live server.
- */
-let deltaCounter = 0;
-/** Reset the delta counter (call in beforeEach for deterministic IDs) */
-export function resetDeltaCounter() {
-    deltaCounter = 0;
-}
-/**
- * Builds a single delta ({@link SyncAction}) in the server's wire format.
- */
-export function createDelta(options) {
-    deltaCounter++;
-    return {
-        id: options.id ?? deltaCounter,
-        modelName: options.modelName,
-        modelId: options.modelId,
-        action: options.action,
-        data: options.data ?? {},
-        __class: 'SyncAction',
-    };
-}
-/**
- * Builds an insert delta for a new entity.
- */
-export function createInsertDelta(modelName, modelId, data, syncId) {
-    return createDelta({ modelName, modelId, action: 'I', data, id: syncId });
-}
-/**
- * Builds an update delta for an existing entity.
- */
-export function createUpdateDelta(modelName, modelId, data, syncId) {
-    return createDelta({ modelName, modelId, action: 'U', data, id: syncId });
-}
-/**
- * Builds a delete delta.
- */
-export function createDeleteDelta(modelName, modelId, syncId) {
-    return createDelta({ modelName, modelId, action: 'D', data: {}, id: syncId });
-}
-/**
- * Builds an archive delta, stamping `archivedAt` with the current time.
- */
-export function createArchiveDelta(modelName, modelId, syncId) {
-    return createDelta({
-        modelName,
-        modelId,
-        action: 'A',
-        data: { archivedAt: new Date().toISOString() },
-        id: syncId,
-    });
-}
-/**
- * Builds an unarchive delta, clearing `archivedAt`.
- */
-export function createUnarchiveDelta(modelName, modelId, syncId) {
-    return createDelta({
-        modelName,
-        modelId,
-        action: 'V',
-        data: { archivedAt: null },
-        id: syncId,
-    });
-}
-/**
- * Builds a covering ('C') delta. It signals that the client has gained
- * permission to see an entity that already exists. The client treats it
- * like an insert, adding the entity to its local store as if newly created.
- * A covering delta typically follows a group-added delta.
- */
-export function createCoveringDelta(modelName, modelId, data, syncId) {
-    return createDelta({ modelName, modelId, action: 'C', data, id: syncId });
-}
-/**
- * Builds a group-added ('G') delta in the incremental payload shape. It
- * signals that the recipient was added to a single sync group. The client
- * updates its subscription state and waits for covering deltas to deliver
- * the newly visible entities. Unlike the older payload that carries both
- * added and removed groups, this shape does not trigger a re-bootstrap.
- */
-export function createGroupAddedDelta(userId, group, syncId) {
-    return createDelta({
-        modelName: 'SyncGroupChange',
-        modelId: `sga_${userId}`,
-        action: 'G',
-        data: { group, userId },
-        id: syncId,
-    });
-}
-/**
- * Builds a group-change ('G') delta in the older payload shape, which
- * carries both added and removed groups in one delta and forces a full
- * re-bootstrap on the client. Useful for testing backward compatibility
- * with that older shape.
- */
-export function createLegacyGroupChangeDelta(userId, added, removed, syncId) {
-    return createDelta({
-        modelName: 'SyncGroupChange',
-        modelId: `sgc_${userId}`,
-        action: 'G',
-        data: { addedGroups: added, removedGroups: removed },
-        id: syncId,
-    });
-}
-/**
- * Builds a group-removed ('S') delta. It signals that the recipient lost
- * access to a sync group. The client purges the affected local state and
- * re-bootstraps with the updated group list.
- */
-export function createGroupRemovedDelta(userId, group, syncId) {
-    return createDelta({
-        modelName: 'SyncGroupChange',
-        modelId: `sgr_${userId}`,
-        action: 'S',
-        data: { group, userId },
-        id: syncId,
-    });
-}
-/**
- * Builds a batch of deltas with sequential sync IDs.
- */
-export function createDeltaBatch(deltas, startingSyncId) {
-    const start = startingSyncId ?? deltaCounter + 1;
-    return deltas.map((d, i) => createDelta({ ...d, id: start + i }));
-}
-/**
- * Builds a confirmation delta, which signals that a mutation was persisted
- * by the server. The client's transaction queue watches for these to
- * confirm its in-flight writes.
- */
-export function createConfirmationDelta(modelName, modelId, syncId, action = 'U', data = {}) {
-    return createDelta({ modelName, modelId, action, data, id: syncId });
-}