@abloatai/ablo 0.26.0 → 0.28.0

package/dist/transactions/optimistic.d.ts

@@ -1,24 +0,0 @@
-/**
- * Optimistic apply/rollback — the queue's local-first bookkeeping, lifted out
- * of `TransactionQueue.ts` as a pure leaf. The queue never mutates the pool
- * itself: applying/rolling back records an entry in the host-owned ledger and
- * emits `optimistic:*` events that the pool-side listeners act on. These
- * functions take that ledger plus a minimal emitter interface (never the host
- * class type), so the rules stay cycle-free and testable in isolation.
- */
-import type { Model } from '../Model.js';
-import type { MutationInput, Transaction } from './commitPayload.js';
-/** One tracked optimistic mutation: the live model + its pre-image. */
-export interface OptimisticUpdateEntry {
-    model: Model;
-    previousState: MutationInput | null | undefined;
-    transaction: Transaction;
-}
-/** The host's event surface — the only queue capability these rules need. */
-export interface OptimisticEmitter {
-    emit(event: string, payload: unknown): void;
-}
-export declare function applyOptimisticCreate(optimisticUpdates: Map<string, OptimisticUpdateEntry>, emitter: OptimisticEmitter, model: Model, transaction: Transaction): void;
-export declare function applyOptimisticUpdate(optimisticUpdates: Map<string, OptimisticUpdateEntry>, emitter: OptimisticEmitter, model: Model, transaction: Transaction): void;
-export declare function applyOptimisticDelete(optimisticUpdates: Map<string, OptimisticUpdateEntry>, emitter: OptimisticEmitter, model: Model, transaction: Transaction): void;
-export declare function rollbackOptimistic(optimisticUpdates: Map<string, OptimisticUpdateEntry>, emitter: OptimisticEmitter, transaction: Transaction, reason?: string, error?: Error): Promise<void>;

package/dist/transactions/optimistic.js

@@ -1,45 +0,0 @@
-/**
- * Optimistic apply/rollback — the queue's local-first bookkeeping, lifted out
- * of `TransactionQueue.ts` as a pure leaf. The queue never mutates the pool
- * itself: applying/rolling back records an entry in the host-owned ledger and
- * emits `optimistic:*` events that the pool-side listeners act on. These
- * functions take that ledger plus a minimal emitter interface (never the host
- * class type), so the rules stay cycle-free and testable in isolation.
- */
-export function applyOptimisticCreate(optimisticUpdates, emitter, model, transaction) {
-    optimisticUpdates.set(transaction.id, {
-        model,
-        previousState: null,
-        transaction,
-    });
-    emitter.emit('optimistic:create', { model, transaction });
-}
-export function applyOptimisticUpdate(optimisticUpdates, emitter, model, transaction) {
-    optimisticUpdates.set(transaction.id, {
-        model,
-        previousState: transaction.previousData,
-        transaction,
-    });
-    emitter.emit('optimistic:update', { model, transaction });
-}
-export function applyOptimisticDelete(optimisticUpdates, emitter, model, transaction) {
-    optimisticUpdates.set(transaction.id, {
-        model,
-        previousState: transaction.previousData,
-        transaction,
-    });
-    emitter.emit('optimistic:delete', { model, transaction });
-}
-export async function rollbackOptimistic(optimisticUpdates, emitter, transaction, reason, error) {
-    const optimistic = optimisticUpdates.get(transaction.id);
-    if (!optimistic)
-        return;
-    emitter.emit('optimistic:rollback', {
-        model: optimistic.model,
-        previousState: optimistic.previousState,
-        transaction,
-        reason: reason ?? 'unknown',
-        error,
-    });
-    optimisticUpdates.delete(transaction.id);
-}

package/dist/transactions/persistedReplay.d.ts

@@ -1,93 +0,0 @@
-/**
- * persistedReplay — the Zod boundary for IDB → commit replay (T1.8).
- *
- * Rows read back from the persisted-transaction store were written by a
- * PREVIOUS session — possibly by an older SDK version, possibly corrupted.
- * Spreading them straight into a `Transaction` re-entered the commit path
- * with zero validation. These schemas validate exactly the fields the queue
- * (and the offline mutation-queue restore) actually read on replay; rows
- * that don't parse are DROPPED (and surfaced through observability), never
- * replayed as garbage commits.
- *
- * The same IDB store also holds two NON-replayable row kinds written by
- * other subsystems — the `'queue'` record (`SyncClient.persistMutationQueue`)
- * and `'awaiting_delta'` markers (`setupAwaitingTransactionPersistence`).
- * Those are recognized and skipped silently: they are expected neighbors,
- * not corruption.
- */
-import { z } from 'zod';
-import type { Transaction } from './commitPayload.js';
-/**
- * A replayable persisted transaction — the fields `TransactionQueue`
- * actually reads when re-enqueueing (id/type/model addressing + payload +
- * identity context). Everything else is defaulted at rehydration time.
- */
-export declare const persistedTransactionSchema: z.ZodObject<{
-    id: z.ZodString;
-    type: z.ZodEnum<{
-        update: "update";
-        create: "create";
-        delete: "delete";
-        archive: "archive";
-        unarchive: "unarchive";
-    }>;
-    modelName: z.ZodString;
-    modelId: z.ZodString;
-    modelKey: z.ZodOptional<z.ZodString>;
-    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    previousData: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-    context: z.ZodObject<{
-        userId: z.ZodString;
-        organizationId: z.ZodString;
-        role: z.ZodOptional<z.ZodString>;
-        teamIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>;
-    createdAt: z.ZodOptional<z.ZodNumber>;
-    batchId: z.ZodOptional<z.ZodString>;
-    writeOptions: z.ZodOptional<z.ZodObject<{
-        readAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        onStale: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-            reject: "reject";
-            overwrite: "overwrite";
-            notify: "notify";
-        }>>>;
-        idempotencyKey: z.ZodOptional<z.ZodString>;
-        label: z.ZodOptional<z.ZodString>;
-    }, z.core.$loose>>;
-    localOnly: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$loose>;
-export type PersistedReplayableTransaction = z.infer<typeof persistedTransactionSchema>;
-/** Whether a persisted row belongs to another subsystem (skip, don't flag). */
-export declare function isNonReplayablePersistedRow(row: unknown): boolean;
-/**
- * Validate + rehydrate one persisted row into a replayable `Transaction`,
- * or `null` when the row doesn't parse. Missing bookkeeping fields are
- * re-derived exactly like a fresh staging would derive them.
- */
-export declare function deserializePersistedTransaction(row: unknown): Transaction | null;
-/**
- * One entry of the persisted offline mutation queue (the `'queue'` row's
- * `mutations` array) — the fields `SyncClient.restoreMutationQueue` reads.
- */
-export declare const persistedMutationSchema: z.ZodObject<{
-    type: z.ZodEnum<{
-        update: "update";
-        create: "create";
-        delete: "delete";
-        archive: "archive";
-    }>;
-    modelData: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    modelName: z.ZodString;
-    timestamp: z.ZodString;
-    writeOptions: z.ZodOptional<z.ZodObject<{
-        readAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        onStale: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-            reject: "reject";
-            overwrite: "overwrite";
-            notify: "notify";
-        }>>>;
-        idempotencyKey: z.ZodOptional<z.ZodString>;
-        label: z.ZodOptional<z.ZodString>;
-    }, z.core.$loose>>;
-}, z.core.$loose>;
-export type PersistedQueuedMutation = z.infer<typeof persistedMutationSchema>;

package/dist/transactions/persistedReplay.js

@@ -1,105 +0,0 @@
-/**
- * persistedReplay — the Zod boundary for IDB → commit replay (T1.8).
- *
- * Rows read back from the persisted-transaction store were written by a
- * PREVIOUS session — possibly by an older SDK version, possibly corrupted.
- * Spreading them straight into a `Transaction` re-entered the commit path
- * with zero validation. These schemas validate exactly the fields the queue
- * (and the offline mutation-queue restore) actually read on replay; rows
- * that don't parse are DROPPED (and surfaced through observability), never
- * replayed as garbage commits.
- *
- * The same IDB store also holds two NON-replayable row kinds written by
- * other subsystems — the `'queue'` record (`SyncClient.persistMutationQueue`)
- * and `'awaiting_delta'` markers (`setupAwaitingTransactionPersistence`).
- * Those are recognized and skipped silently: they are expected neighbors,
- * not corruption.
- */
-import { z } from 'zod';
-import { computePriorityScore, normalizeModelKey } from './commitPayload.js';
-/** Write-option subset persisted per transaction / mutation. */
-const persistedWriteOptionsSchema = z
-    .object({
-    readAt: z.number().nullable().optional(),
-    onStale: z.enum(['reject', 'overwrite', 'notify']).nullable().optional(),
-    idempotencyKey: z.string().optional(),
-    label: z.string().optional(),
-})
-    .passthrough();
-/**
- * A replayable persisted transaction — the fields `TransactionQueue`
- * actually reads when re-enqueueing (id/type/model addressing + payload +
- * identity context). Everything else is defaulted at rehydration time.
- */
-export const persistedTransactionSchema = z
-    .object({
-    id: z.string().min(1),
-    type: z.enum(['create', 'update', 'delete', 'archive', 'unarchive']),
-    modelName: z.string().min(1),
-    modelId: z.string().min(1),
-    modelKey: z.string().min(1).optional(),
-    data: z.record(z.string(), z.unknown()).optional(),
-    previousData: z.record(z.string(), z.unknown()).nullable().optional(),
-    context: z.object({
-        userId: z.string().min(1),
-        organizationId: z.string().min(1),
-        role: z.string().optional(),
-        teamIds: z.array(z.string()).optional(),
-    }),
-    createdAt: z.number().optional(),
-    batchId: z.string().optional(),
-    writeOptions: persistedWriteOptionsSchema.optional(),
-    localOnly: z.boolean().optional(),
-})
-    .passthrough();
-/** Row kinds that share the store but are owned by other subsystems. */
-const NON_REPLAYABLE_TYPES = new Set(['queue', 'awaiting_delta']);
-/** Whether a persisted row belongs to another subsystem (skip, don't flag). */
-export function isNonReplayablePersistedRow(row) {
-    return (typeof row === 'object' &&
-        row !== null &&
-        typeof row.type === 'string' &&
-        NON_REPLAYABLE_TYPES.has(row.type));
-}
-/**
- * Validate + rehydrate one persisted row into a replayable `Transaction`,
- * or `null` when the row doesn't parse. Missing bookkeeping fields are
- * re-derived exactly like a fresh staging would derive them.
- */
-export function deserializePersistedTransaction(row) {
-    const parsed = persistedTransactionSchema.safeParse(row);
-    if (!parsed.success)
-        return null;
-    const tx = parsed.data;
-    return {
-        id: tx.id,
-        type: tx.type,
-        modelName: tx.modelName,
-        modelId: tx.modelId,
-        modelKey: tx.modelKey ?? normalizeModelKey(tx.modelName),
-        ...(tx.data !== undefined ? { data: tx.data } : {}),
-        ...(tx.previousData !== undefined ? { previousData: tx.previousData } : {}),
-        context: tx.context,
-        status: 'pending',
-        createdAt: tx.createdAt ?? Date.now(),
-        attempts: 0,
-        priority: 'normal',
-        priorityScore: computePriorityScore(tx.type, tx.modelName),
-        ...(tx.batchId !== undefined ? { batchId: tx.batchId } : {}),
-        ...(tx.writeOptions !== undefined ? { writeOptions: tx.writeOptions } : {}),
-        ...(tx.localOnly !== undefined ? { localOnly: tx.localOnly } : {}),
-    };
-}
-/**
- * One entry of the persisted offline mutation queue (the `'queue'` row's
- * `mutations` array) — the fields `SyncClient.restoreMutationQueue` reads.
- */
-export const persistedMutationSchema = z
-    .object({
-    type: z.enum(['create', 'update', 'delete', 'archive']),
-    modelData: z.record(z.string(), z.unknown()),
-    modelName: z.string().min(1),
-    timestamp: z.string(),
-    writeOptions: persistedWriteOptionsSchema.optional(),
-})
-    .passthrough();

package/dist/utils/mobx-setup.d.ts

@@ -1,42 +0,0 @@
-/**
- * M1 Helper - Simplified MobX Setup
- *
- * Fixed version that doesn't conflict with existing getters/setters
- */
-import { type AnnotationMapEntry } from 'mobx';
-import { type PropertyMetadata, type ReferenceMetadata } from '../types/index.js';
-/**
- * The internal contract M1 relies on. Models invoke M1 from inside
- * their constructor, where these fields are guaranteed to exist on
- * `this`. Declared here as the bound on M1's generic so the body can
- * reference them without `as any` casts. Each field is optional so a
- * partial Model implementation (e.g., a test fixture) still satisfies
- * the bound.
- */
-interface M1Target {
-    _hasCustomObservability?: boolean;
-    _isConstructing?: boolean;
-    _extraMobxAnnotations?: Record<string, AnnotationMapEntry>;
-    setupObservability?(): void;
-    propertyChanged?(name: string, oldValue: unknown, newValue: unknown): void;
-}
-/**
- * M1 - Make properties observable with proper MobX setup
- *
- * Simplified version that respects existing getters/setters
- */
-export declare function M1<T extends M1Target>(target: T, propertyMetadata: Map<string, PropertyMetadata>, referenceMetadata?: Map<string, ReferenceMetadata>): void;
-/**
- * Helper to make a class observable
- * For classes that don't have custom observability
- */
-export declare function makeModelObservable(modelClass: any, propertyMetadata: Map<string, PropertyMetadata>, referenceMetadata?: Map<string, any>): any;
-/**
- * Utility to check if a property is observable
- */
-export declare function isObservableProperty(target: any, propName: string, propertyMetadata: Map<string, PropertyMetadata>): boolean;
-/**
- * Utility to get computed properties
- */
-export declare function getComputedProperties(propertyMetadata: Map<string, PropertyMetadata>): string[];
-export {};