@abloatai/ablo 0.3.1 → 0.4.0

package/dist/client/createModelProxy.d.ts

@@ -8,9 +8,9 @@
  *
  * Each schema model gets one `ModelOperations<T, CreateInput>` —
  * exposes `retrieve`, `list`, `count`, `create`, `update`, `delete`,
- * `edit`,
- * `subscribe`, and `load`. The factory returns a plain object; the
- * client assembles `ablo.<model>` lookup table from these.
+ * `intent` (the coordination handle), `subscribe`, and `load`. The
+ * factory returns a plain object; the client assembles the
+ * `ablo.<model>` lookup table from these.
  */
 import type { MutationOptions } from '../interfaces/index.js';
 import type { ModelRegistry } from '../ModelRegistry.js';
@@ -19,7 +19,7 @@ import type { SyncClient } from '../SyncClient.js';
 import type { HydrationCoordinator } from '../sync/HydrationCoordinator.js';
 import type { LoadWhere } from '../query/types.js';
 import { ModelScope } from '../types/index.js';
-import type { Duration, Snapshot } from '../types/streams.js';
+import type { Duration, Intent, IntentStatus, IntentWaitOptions, Snapshot } from '../types/streams.js';
 export interface ModelResourceMeta {
     readonly key: string;
     readonly typename: string;
@@ -66,30 +66,7 @@ export interface ModelLoadOptions<T> {
      */
     expand?: readonly string[];
 }
-export interface ModelEditOptions<T = Record<string, unknown>> {
-    /**
-     * Human-readable activity shown to other participants while this handle
-     * is open. Examples: `editing`, `summarizing`, `rewriting`, `reviewing`.
-     */
-    activity?: string;
-    /** Optional field-level target for UI affordances such as busy badges. */
-    field?: keyof T & string;
-    /** Lease duration for the visible activity. Runtime death is cleaned up by TTL. */
-    ttl?: Duration;
-    /** Default wait mode for `handle.update(...)`. Defaults to `confirmed`. */
-    wait?: MutationOptions['wait'];
-}
-export interface ModelEditHandle<T> extends AsyncDisposable {
-    readonly id: string;
-    readonly intentId: string;
-    readonly activity: string;
-    readonly current: T;
-    readonly signal: AbortSignal;
-    update(data: Partial<T>, options?: MutationOptions): Promise<T>;
-    release(): Promise<void>;
-    revoke(): void;
-}
-export interface ModelIntentHandle {
+export interface IntentLeaseHandle {
     readonly id: string;
     release(): Promise<void>;
     revoke(): void;
@@ -103,8 +80,99 @@ export interface ModelCollaboration<T> {
         };
         action: string;
         ttl?: Duration;
-    }): Promise<ModelIntentHandle>;
+    }): Promise<IntentLeaseHandle>;
     createSnapshot(modelKey: string, id: string): Snapshot;
+    /**
+     * Current coordination state on a target — who (if anyone) holds it.
+     * Synchronous reactive snapshot read off the presence/intent stream;
+     * `null` when the target is free. The wiring site computes it because
+     * only it knows the local participant id (needed to distinguish "I
+     * hold it" from "someone else holds it").
+     */
+    observe(target: {
+        resource: string;
+        id: string;
+    }): Intent | null;
+    /**
+     * Resolve once no participant holds an active intent on the target.
+     * The contender's "wait until it's free" — delegates to the intent
+     * stream's `waitFor`.
+     */
+    waitFor(target: {
+        resource: string;
+        id: string;
+    }, options?: IntentWaitOptions): Promise<void>;
+    /**
+     * The local participant's id. Used to distinguish "I already hold this"
+     * from "someone else holds it" in `acquireOrAwait`.
+     */
+    readonly selfParticipantId: string;
+}
+/** Options for acquiring a per-model coordination intent. */
+export interface ModelIntentAcquireOptions {
+    /** Phase shown to others while held. Defaults to `'editing'`. */
+    action?: string;
+    /** Field-level target for busy badges. */
+    field?: string;
+    /** Lease duration; runtime death is cleaned up by TTL. */
+    ttl?: Duration;
+    /** Default wait mode for `handle.update(...)`. Defaults to `confirmed`. */
+    wait?: MutationOptions['wait'];
+}
+/**
+ * Per-entity coordination handle — the same accessor shape as
+ * `create`/`update`/`retrieve`, but on the coordination plane. Returned
+ * synchronously by `ablo.<model>.intent(id)` so a contender can read
+ * `.current` without awaiting; `acquire()` is the async lock.
+ *
+ * Read side (any participant): `current`, `status`, `settled()`.
+ * Write side (the holder): `acquire()`, `update()`, `release()`.
+ */
+export interface ModelIntentHandle<T> extends AsyncDisposable {
+    /** The target entity id this handle coordinates. */
+    readonly id: string;
+    /**
+     * Live coordination state on this target — `null` when free, otherwise
+     * the holder's `Intent` (who, what phase, until when). Reactive
+     * snapshot; pair with the model's `subscribe` for change notifications.
+     */
+    readonly current: Intent | null;
+    /** Convenience: `current?.status ?? 'idle'`. */
+    readonly status: IntentStatus | 'idle';
+    /**
+     * Acquire the lease so other participants yield. Resolves once the
+     * claim is announced. Throws if another participant already holds it
+     * (cooperative mutex enforced at the server boundary).
+     */
+    acquire(options?: ModelIntentAcquireOptions): Promise<void>;
+    /**
+     * Acquire the target, or — if another participant holds it — wait for
+     * them to finish, re-read the (now-changed) row, then acquire. This is
+     * the runtime's serialize-on-contention primitive: the caller never
+     * branches on who holds the target, it just gets the target safely.
+     *
+     * A claim held by *this* participant is treated as already-mine and
+     * acquired without waiting. Bind this to an agent's write-tool boundary
+     * so agents never reason about coordination themselves.
+     */
+    acquireOrAwait(options?: ModelIntentAcquireOptions): Promise<void>;
+    /**
+     * Optimistic update guarded by the lease this handle holds. Rejects
+     * with `AbloStaleContextError` if the row changed under you, then
+     * auto-releases. Call `acquire()` first.
+     */
+    update(data: Partial<T>, options?: MutationOptions): Promise<T>;
+    /** Release a lease you hold (commit / abandon). */
+    release(): Promise<void>;
+    /**
+     * Wait until the target is free, then resolve. The contender's
+     * "let me wait until it completes." On resolution your cached copy may
+     * be stale — re-read before writing (the stale-context guard enforces
+     * this if you go through `acquire().update()`).
+     */
+    settled(options?: IntentWaitOptions): Promise<void>;
+    /** Drop a held lease without committing. */
+    revoke(): void;
 }
 export interface ModelOperations<T, CreateInput> {
     /**
@@ -135,10 +203,20 @@ export interface ModelOperations<T, CreateInput> {
     /** Delete an entity by id — optimistic, offline-first (see `create`). */
     delete(id: string, options?: MutationOptions): Promise<void>;
     /**
-     * Start a model-scoped activity lease for long-running AI or background work.
-     * Other participants can see the activity until `update`, `release`, or TTL.
+     * Coordination accessor for one entity — the same `ablo.<model>(id)`
+     * shape as `create`/`update`/`retrieve`, but on the coordination plane
+     * (ephemeral, TTL'd, never persisted). Returns a handle synchronously:
+     * read `.current` to see who's editing, `acquire()` to lock, `update()`
+     * to write under the lock, `settled()` to wait for a holder to finish.
+     *
+     * ```ts
+     * const lock = ablo.slide.intent(slideId);
+     * if (lock.current) await lock.settled();   // someone's editing — wait
+     * await lock.acquire({ action: 'editing' });
+     * await lock.update({ title: 'New' });      // auto-releases
+     * ```
      */
-    edit(id: string, options?: ModelEditOptions<T>): Promise<ModelEditHandle<T>>;
+    intent(id: string): ModelIntentHandle<T>;
     /** Subscribe to changes (callback called on every change). */
     subscribe(callback: (entities: T[]) => void, options?: ModelListOptions<T>): () => void;
     /**

package/dist/client/createModelProxy.js

@@ -8,9 +8,9 @@
  *
  * Each schema model gets one `ModelOperations<T, CreateInput>` —
  * exposes `retrieve`, `list`, `count`, `create`, `update`, `delete`,
- * `edit`,
- * `subscribe`, and `load`. The factory returns a plain object; the
- * client assembles `ablo.<model>` lookup table from these.
+ * `intent` (the coordination handle), `subscribe`, and `load`. The
+ * factory returns a plain object; the client assembles the
+ * `ablo.<model>` lookup table from these.
  */
 import { autorun } from 'mobx';
 import { AbloStaleContextError, AbloValidationError } from '../errors.js';
@@ -111,54 +111,92 @@ export function createModelProxy(schemaKey, registeredModelName, objectPool, syn
             syncClient.delete(model, options);
             await waitForMutation(model, options);
         },
-        async edit(id, options) {
-            if (!collaboration) {
-                throw new AbloValidationError(`Model "${schemaKey}" cannot start edit activity without collaboration wiring.`, { code: 'model_edit_not_configured' });
-            }
-            let model = objectPool.get(id);
-            if (!model) {
-                await load({ where: { id } });
-                model = objectPool.get(id);
-            }
-            if (!model) {
-                throw new AbloValidationError(`Entity not found: ${registeredModelName}/${id}`, { code: 'entity_not_found' });
-            }
-            const activity = options?.activity ?? 'editing';
-            const snapshot = collaboration.createSnapshot(schemaKey, id);
-            const intent = await collaboration.createIntent({
-                target: {
-                    resource: schemaKey,
-                    id,
-                    ...(options?.field ? { field: options.field } : {}),
-                },
-                action: activity,
-                ttl: options?.ttl,
-            });
+        intent(id) {
+            const target = { resource: schemaKey, id };
+            let acquired = null;
+            let snapshot = null;
             let released = false;
+            let acquireWait;
             const revoke = () => {
                 if (released)
                     return;
                 released = true;
-                snapshot.signal.removeEventListener('abort', revoke);
-                intent.revoke();
+                if (snapshot)
+                    snapshot.signal.removeEventListener('abort', revoke);
+                acquired?.revoke();
             };
             const release = async () => {
                 if (released)
                     return;
                 released = true;
-                snapshot.signal.removeEventListener('abort', revoke);
-                await intent.release();
+                if (snapshot)
+                    snapshot.signal.removeEventListener('abort', revoke);
+                await acquired?.release();
+            };
+            const settled = async (options) => {
+                if (!collaboration)
+                    return;
+                await collaboration.waitFor(target, options);
+            };
+            const acquire = async (options) => {
+                if (!collaboration) {
+                    throw new AbloValidationError(`Model "${schemaKey}" cannot acquire an intent without collaboration wiring.`, { code: 'model_intent_not_configured' });
+                }
+                if (acquired)
+                    return;
+                acquireWait = options?.wait;
+                // Load the row so update() has a snapshot to guard against.
+                let model = objectPool.get(id);
+                if (!model) {
+                    await load({ where: { id } });
+                    model = objectPool.get(id);
+                }
+                if (!model) {
+                    throw new AbloValidationError(`Entity not found: ${registeredModelName}/${id}`, { code: 'entity_not_found' });
+                }
+                const snap = collaboration.createSnapshot(schemaKey, id);
+                snap.signal.addEventListener('abort', revoke, { once: true });
+                snapshot = snap;
+                released = false;
+                acquired = await collaboration.createIntent({
+                    target: {
+                        resource: schemaKey,
+                        id,
+                        ...(options?.field ? { field: options.field } : {}),
+                    },
+                    action: options?.action ?? 'editing',
+                    ttl: options?.ttl,
+                });
+            };
+            const acquireOrAwait = async (options) => {
+                if (!collaboration) {
+                    throw new AbloValidationError(`Model "${schemaKey}" cannot acquire an intent without collaboration wiring.`, { code: 'model_intent_not_configured' });
+                }
+                const held = collaboration.observe(target);
+                // A foreign holder: wait for release, then re-read before claiming.
+                // Our own claim (or a free target) skips straight to acquire.
+                if (held && held.heldBy !== collaboration.selfParticipantId) {
+                    await settled();
+                    await load({ where: { id } });
+                }
+                await acquire(options);
             };
-            snapshot.signal.addEventListener('abort', revoke, { once: true });
             const handle = {
                 id,
-                intentId: intent.id,
-                activity,
-                current: modelAsRow(model),
-                signal: snapshot.signal,
+                get current() {
+                    return collaboration?.observe(target) ?? null;
+                },
+                get status() {
+                    return collaboration?.observe(target)?.status ?? 'idle';
+                },
+                acquire,
+                acquireOrAwait,
                 async update(data, updateOptions) {
+                    if (!acquired || !snapshot) {
+                        throw new AbloValidationError(`Call acquire() before update() on ablo.${schemaKey}.intent(${id}).`, { code: 'intent_not_acquired' });
+                    }
                     if (snapshot.signal.aborted) {
-                        throw new AbloStaleContextError(`Edit context is stale for ${schemaKey}/${id}. Re-read the row and retry.`, {
+                        throw new AbloStaleContextError(`Intent context is stale for ${schemaKey}/${id}. Re-read the row and retry.`, {
                             code: 'edit_context_stale',
                             readAt: snapshot.stamp,
                             cause: snapshot.signal.reason,
@@ -166,11 +204,11 @@ export function createModelProxy(schemaKey, registeredModelName, objectPool, syn
                     }
                     try {
                         return await operations.update(id, data, {
-                            wait: options?.wait ?? 'confirmed',
+                            wait: acquireWait ?? 'confirmed',
                             readAt: snapshot.stamp,
                             onStale: 'reject',
                             ...updateOptions,
-                            intent,
+                            intent: acquired,
                         });
                     }
                     finally {
@@ -178,6 +216,7 @@ export function createModelProxy(schemaKey, registeredModelName, objectPool, syn
                     }
                 },
                 release,
+                settled,
                 revoke,
                 [Symbol.asyncDispose]: release,
             };

package/dist/client/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @ablo/sync-engine/client — Consumer API
+ * @abloatai/ablo/client — Consumer API
  *
  * The one-liner entry point for external consumers.
  *
@@ -7,7 +7,7 @@
  * when you want the realtime sync engine with typed model proxies.
  *
  * ```ts
- * import { Ablo } from '@ablo/sync-engine/client';
+ * import { Ablo } from '@abloatai/ablo/client';
  * import { schema } from './schema';
  *
  * const ablo = Ablo({

package/dist/client/index.js

@@ -1,5 +1,5 @@
 /**
- * @ablo/sync-engine/client — Consumer API
+ * @abloatai/ablo/client — Consumer API
  *
  * The one-liner entry point for external consumers.
  *
@@ -7,7 +7,7 @@
  * when you want the realtime sync engine with typed model proxies.
  *
  * ```ts
- * import { Ablo } from '@ablo/sync-engine/client';
+ * import { Ablo } from '@abloatai/ablo/client';
  * import { schema } from './schema';
  *
  * const ablo = Ablo({

package/dist/config/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @ablo/sync-engine/config — App initialization
+ * @abloatai/ablo/config — App initialization
  *
  * One-time setup at app boot. Provides DI interface types
  * and the initSyncEngine() function to wire real implementations.

package/dist/config/index.js

@@ -1,5 +1,5 @@
 /**
- * @ablo/sync-engine/config — App initialization
+ * @abloatai/ablo/config — App initialization
  *
  * One-time setup at app boot. Provides DI interface types
  * and the initSyncEngine() function to wire real implementations.

package/dist/core/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @ablo/sync-engine-internal/core — Framework extension
+ * @abloatai/ablo/core — Framework extension
  *
  * Only imported by SyncedStore.ts and ApplicationStore.ts —
  * the 2-3 files that extend or orchestrate the sync engine.

package/dist/core/index.js

@@ -1,5 +1,5 @@
 /**
- * @ablo/sync-engine-internal/core — Framework extension
+ * @abloatai/ablo/core — Framework extension
  *
  * Only imported by SyncedStore.ts and ApplicationStore.ts —
  * the 2-3 files that extend or orchestrate the sync engine.
@@ -13,7 +13,7 @@ export { Database } from '../Database.js';
 export { ObjectPool, ModelScope } from '../ObjectPool.js';
 export { Model } from '../Model.js';
 export { LazyReferenceCollection } from '../LazyReferenceCollection.js';
-// Undo runtime — `useUndoScope` hook from `@ablo/sync-engine/react` is
+// Undo runtime — `useUndoScope` hook from `@abloatai/ablo/react` is
 // the canonical access path. Type counterparts (`Ablo.Mutator.UndoScope`,
 // `Ablo.Mutator.UndoEntry`, `Ablo.Mutator.InverseOp`) live on the main `Ablo`
 // namespace. Direct class access (tests, non-React hosts) imports via

package/dist/errors.d.ts

@@ -1,5 +1,5 @@
 /**
- * Typed error hierarchy for `@ablo/sync-engine`.
+ * Typed error hierarchy for `@abloatai/ablo`.
  *
  * Inlined directly so the publishable dist is self-contained. The public
  * package should never reference an unpublished internal package from emitted

package/dist/errors.js

@@ -1,5 +1,5 @@
 /**
- * Typed error hierarchy for `@ablo/sync-engine`.
+ * Typed error hierarchy for `@abloatai/ablo`.
  *
  * Inlined directly so the publishable dist is self-contained. The public
  * package should never reference an unpublished internal package from emitted

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 /**
- * @ablo/sync-engine — The Collaboration Layer for AI and Humans
+ * @abloatai/ablo — The Collaboration Layer for AI and Humans
  *
  * ```ts
- * import Ablo from '@ablo/sync-engine';
+ * import Ablo from '@abloatai/ablo';
  *
  * const ablo = Ablo({ schema, apiKey: process.env.ABLO_API_KEY });
  * await ablo.tasks.load({ where: { id: 'task_123' } });
@@ -19,16 +19,16 @@
  * reached via dot-access on the engine, types via namespace dots.
  *
  * Public subpaths:
- *   @ablo/sync-engine/schema   — defineSchema, model, z (Zod)
- *   @ablo/sync-engine/react    — <AbloProvider>, useQuery, useMutate
- *   @ablo/sync-engine/testing  — test harnesses + mocks
+ *   @abloatai/ablo/schema   — defineSchema, model, z (Zod)
+ *   @abloatai/ablo/react    — <AbloProvider>, useQuery, useMutate
+ *   @abloatai/ablo/testing  — test harnesses + mocks
  *
  * Consumer code should converge on `ablo.<model>.load(...)`, which routes
  * through the engine's `HydrationCoordinator` and dedupes single-flight
  * hydrations.
  */
 export { Ablo } from './client/Ablo.js';
-export type { AbloOptions, ModelCountOptions, ModelListOptions, ModelListScope, ModelLoadOptions, ModelEditHandle, ModelEditOptions, ModelOperations, } from './client/Ablo.js';
+export type { AbloOptions, ModelCountOptions, ModelListOptions, ModelListScope, ModelLoadOptions, ModelIntentHandle, ModelIntentAcquireOptions, ModelOperations, } from './client/Ablo.js';
 export type { AbloPersistence } from './client/persistence.js';
 export { session, agent } from './principal.js';
 import { Ablo } from './client/Ablo.js';

package/dist/index.js

@@ -1,8 +1,8 @@
 /**
- * @ablo/sync-engine — The Collaboration Layer for AI and Humans
+ * @abloatai/ablo — The Collaboration Layer for AI and Humans
  *
  * ```ts
- * import Ablo from '@ablo/sync-engine';
+ * import Ablo from '@abloatai/ablo';
  *
  * const ablo = Ablo({ schema, apiKey: process.env.ABLO_API_KEY });
  * await ablo.tasks.load({ where: { id: 'task_123' } });
@@ -19,9 +19,9 @@
  * reached via dot-access on the engine, types via namespace dots.
  *
  * Public subpaths:
- *   @ablo/sync-engine/schema   — defineSchema, model, z (Zod)
- *   @ablo/sync-engine/react    — <AbloProvider>, useQuery, useMutate
- *   @ablo/sync-engine/testing  — test harnesses + mocks
+ *   @abloatai/ablo/schema   — defineSchema, model, z (Zod)
+ *   @abloatai/ablo/react    — <AbloProvider>, useQuery, useMutate
+ *   @abloatai/ablo/testing  — test harnesses + mocks
  *
  * Consumer code should converge on `ablo.<model>.load(...)`, which routes
  * through the engine's `HydrationCoordinator` and dedupes single-flight
@@ -32,7 +32,7 @@
 // Everything else is in a subpath.
 // The canonical surface — `Ablo` is a function, type, and namespace under
 // one name. Matches `Stripe`, `OpenAI`, `Anthropic`. Default export so
-// `import Ablo from '@ablo/sync-engine'` works; named export so
+// `import Ablo from '@abloatai/ablo'` works; named export so
 // `import { Ablo }` also compiles.
 export { Ablo } from './client/Ablo.js';
 // Participant types live under `Ablo.Participant.*` —
@@ -50,9 +50,9 @@ export default Ablo;
 // helpers ship flat; type counterparts live under `Ablo.Source.*`
 // (`Ablo.Source.Operation`, `Ablo.Source.Commit.Params`, etc.).
 export { dataSource, abloSource, signAbloSourceRequest, verifyAbloSourceRequest, } from './source/index.js';
-// Schema DSL is intentionally published from `@ablo/sync-engine/schema`.
+// Schema DSL is intentionally published from `@abloatai/ablo/schema`.
 // Keeping it out of the root import preserves one clean runtime surface:
-// `import Ablo from '@ablo/sync-engine'`.
+// `import Ablo from '@abloatai/ablo'`.
 // Conflict policy — `defaultPolicy` (the rejecting default) is a value
 // callers reference if they want to compose. The type counterparts
 // (`Conflict`, `ConflictPolicy`, etc.) live under `Ablo.Conflict`,
@@ -79,4 +79,4 @@ export { defineMutators } from './mutators/defineMutators.js';
 // pass it as `{ tx, args }` to the mutator function.
 export { createTransaction } from './mutators/Transaction.js';
 // Undo runtime is intentionally not part of the public root surface. App code
-// uses `useUndoScope` from `@ablo/sync-engine/react`.
+// uses `useUndoScope` from `@abloatai/ablo/react`.

package/dist/interfaces/headless.d.ts

@@ -12,7 +12,7 @@
  *   const engine = createSyncEngine({ url, userId, organizationId });
  *
  *   // Node.js / agent / sidecar (headless — DI overrides)
- *   import { inMemoryStorage, alwaysOnline } from '@ablo/sync-engine/headless';
+ *   import { inMemoryStorage, alwaysOnline } from '@abloatai/ablo/headless';
  *   const engine = createSyncEngine({
  *     url, userId, organizationId,
  *     storage: inMemoryStorage(),

package/dist/interfaces/headless.js

@@ -12,7 +12,7 @@
  *   const engine = createSyncEngine({ url, userId, organizationId });
  *
  *   // Node.js / agent / sidecar (headless — DI overrides)
- *   import { inMemoryStorage, alwaysOnline } from '@ablo/sync-engine/headless';
+ *   import { inMemoryStorage, alwaysOnline } from '@abloatai/ablo/headless';
  *   const engine = createSyncEngine({
  *     url, userId, organizationId,
  *     storage: inMemoryStorage(),
@@ -32,7 +32,7 @@ export {};
 //
 // These will be the public API that headless consumers import:
 //
-//   import { inMemoryStorage, alwaysOnline } from '@ablo/sync-engine/headless';
+//   import { inMemoryStorage, alwaysOnline } from '@abloatai/ablo/headless';
 //
 // Stubs below show the intended signatures. Implementation is Phase 1 work.
 // export function inMemoryStorage(): StorageProvider { ... }

package/dist/policy/index.d.ts

@@ -1,11 +1,11 @@
 /**
- * @ablo/sync-engine/policy — pluggable conflict resolution.
+ * @abloatai/ablo/policy — pluggable conflict resolution.
  *
  * The engine detects conflicts; the policy decides. Customer code
  * implements `ConflictPolicy` and registers it at the sync-server.
  *
  * ```ts
- * import { type ConflictPolicy, defaultPolicy } from '@ablo/sync-engine/policy';
+ * import { type ConflictPolicy, defaultPolicy } from '@abloatai/ablo/policy';
  *
  * export const myPolicy: ConflictPolicy = (ctx) => {
  *   if (ctx.committer.id.startsWith('linter:')) {

package/dist/policy/index.js

@@ -1,11 +1,11 @@
 /**
- * @ablo/sync-engine/policy — pluggable conflict resolution.
+ * @abloatai/ablo/policy — pluggable conflict resolution.
  *
  * The engine detects conflicts; the policy decides. Customer code
  * implements `ConflictPolicy` and registers it at the sync-server.
  *
  * ```ts
- * import { type ConflictPolicy, defaultPolicy } from '@ablo/sync-engine/policy';
+ * import { type ConflictPolicy, defaultPolicy } from '@abloatai/ablo/policy';
  *
  * export const myPolicy: ConflictPolicy = (ctx) => {
  *   if (ctx.committer.id.startsWith('linter:')) {

package/dist/principal.d.ts

@@ -4,7 +4,7 @@
  * the discriminated-union tags.
  *
  * ```ts
- * import Ablo, { session } from '@ablo/sync-engine';
+ * import Ablo, { session } from '@abloatai/ablo';
  *
  * const ablo = Ablo({ schema, apiKey });
  * const participant = await ablo.participants.join({

package/dist/principal.js

@@ -4,7 +4,7 @@
  * the discriminated-union tags.
  *
  * ```ts
- * import Ablo, { session } from '@ablo/sync-engine';
+ * import Ablo, { session } from '@abloatai/ablo';
  *
  * const ablo = Ablo({ schema, apiKey });
  * const participant = await ablo.participants.join({

package/dist/react/ClientSideSuspense.d.ts

@@ -15,7 +15,7 @@ import { type ReactNode } from 'react';
  *
  * v0.3.x implementation is non-Suspense: reads `useSyncStatus()` and
  * conditionally renders. v0.3.x+ will ship a
- * `@ablo/sync-engine/react/suspense` subpath where `useQuery` / `useOne`
+ * `@abloatai/ablo/react/suspense` subpath where `useQuery` / `useOne`
  * actually throw Promises; this component becomes a thin wrapper around
  * React's real `<Suspense>` at that point.
  *

package/dist/react/SyncGroupProvider.js

@@ -38,7 +38,7 @@ export function useSyncGroup() {
     if (!id) {
         throw new AbloValidationError('useSyncGroup: no <SyncGroupProvider> mounted above this component. ' +
             'Wrap your tree with <SyncGroupProvider id="matter:..."> from ' +
-            '@ablo/sync-engine/react.', { code: 'no_sync_group_provider' });
+            '@abloatai/ablo/react.', { code: 'no_sync_group_provider' });
     }
     return id;
 }

package/dist/react/context.d.ts

@@ -148,7 +148,7 @@ export interface SyncProviderProps {
  * (useModel, useModels, useMutations) can access it.
  *
  * @example
- * import { SyncProvider } from '@ablo/sync-engine/react';
+ * import { SyncProvider } from '@abloatai/ablo/react';
  *
  * function App() {
  *   return (

package/dist/react/context.js

@@ -20,7 +20,7 @@ export function useSyncContext() {
  * (useModel, useModels, useMutations) can access it.
  *
  * @example
- * import { SyncProvider } from '@ablo/sync-engine/react';
+ * import { SyncProvider } from '@abloatai/ablo/react';
  *
  * function App() {
  *   return (

package/dist/react/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @ablo/sync-engine/react — React bindings (v0.3.0)
+ * @abloatai/ablo/react — React bindings (v0.3.0)
  *
  * Umbrella provider:
  *   <AbloProvider schema={...} userId={...} orgId={...} fallback={<Skeleton/>}>

package/dist/react/index.js

@@ -1,5 +1,5 @@
 /**
- * @ablo/sync-engine/react — React bindings (v0.3.0)
+ * @abloatai/ablo/react — React bindings (v0.3.0)
  *
  * Umbrella provider:
  *   <AbloProvider schema={...} userId={...} orgId={...} fallback={<Skeleton/>}>