@abloatai/ablo 0.3.1 → 0.5.0

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
@@ -186,16 +186,18 @@ export interface CommitReceipt {
     };
 }
 /**
- * Biscuit capability token failed verification — either it's
- * malformed / unknown / revoked (`capability_invalid`), or its
- * caveats deny the attempted action (`capability_scope_denied`).
+ * A scoped credential was denied — either the key is unknown / revoked /
+ * expired (`capability_invalid`), or the connection's resolved scope
+ * doesn't cover the attempted action (`capability_scope_denied`). With
+ * opaque restricted (`rk_`) API keys this is a server-side check against
+ * the key's `syncGroups` / `operations`, not a signed-caveat verification.
  *
  * Extends `AbloPermissionError` so existing `instanceof CapabilityError`
  * checks keep working AND broader `instanceof AbloPermissionError`
- * matches for consumers who don't care about the Biscuit specifics.
+ * matches for consumers who don't care about the scope specifics.
  *
- * `requiredCapability` (when present) describes what an attenuated
- * capability must satisfy for the request to succeed on retry.
+ * `requiredCapability` (when present) describes the scope a key must
+ * carry for the request to succeed on retry.
  */
 export declare class CapabilityError extends AbloPermissionError {
     readonly requiredCapability?: RequiredCapability;

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
@@ -125,16 +125,18 @@ export class AbloBusyError extends AbloError {
     }
 }
 /**
- * Biscuit capability token failed verification — either it's
- * malformed / unknown / revoked (`capability_invalid`), or its
- * caveats deny the attempted action (`capability_scope_denied`).
+ * A scoped credential was denied — either the key is unknown / revoked /
+ * expired (`capability_invalid`), or the connection's resolved scope
+ * doesn't cover the attempted action (`capability_scope_denied`). With
+ * opaque restricted (`rk_`) API keys this is a server-side check against
+ * the key's `syncGroups` / `operations`, not a signed-caveat verification.
  *
  * Extends `AbloPermissionError` so existing `instanceof CapabilityError`
  * checks keep working AND broader `instanceof AbloPermissionError`
- * matches for consumers who don't care about the Biscuit specifics.
+ * matches for consumers who don't care about the scope specifics.
  *
- * `requiredCapability` (when present) describes what an attenuated
- * capability must satisfy for the request to succeed on retry.
+ * `requiredCapability` (when present) describes the scope a key must
+ * carry for the request to succeed on retry.
  */
 export class CapabilityError extends AbloPermissionError {
     requiredCapability;

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,30 @@
  * 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.
+ *
+ * ── What to import (read this first) ────────────────────────────────
+ * Default path — this is all most apps and agents ever need:
+ *   • `Ablo` (default export) + `AbloOptions` + the `Model*Options` bags
+ *   • the `Ablo*Error` classes, to discriminate failures in catch blocks
+ * That's it. If you're reaching past those, you're in advanced territory.
+ *
+ * Advanced — opt-in, most apps never import these (each is tagged
+ * "Advanced —" at its export below, with the one situation it's for):
+ *   • `dataSource` / `abloSource`  — only if your own DB stays canonical
+ *   • `session` / `agent`          — only for delegated agent principals
+ *   • `defaultPolicy`              — only to customize conflict resolution
+ *   • `defineMutators` / `createTransaction` — only for custom mutators
+ * If you don't recognize one, you don't need it — the default path covers you.
  */
 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,44 +19,61 @@
  * 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.
+ *
+ * ── What to import (read this first) ────────────────────────────────
+ * Default path — this is all most apps and agents ever need:
+ *   • `Ablo` (default export) + `AbloOptions` + the `Model*Options` bags
+ *   • the `Ablo*Error` classes, to discriminate failures in catch blocks
+ * That's it. If you're reaching past those, you're in advanced territory.
+ *
+ * Advanced — opt-in, most apps never import these (each is tagged
+ * "Advanced —" at its export below, with the one situation it's for):
+ *   • `dataSource` / `abloSource`  — only if your own DB stays canonical
+ *   • `session` / `agent`          — only for delegated agent principals
+ *   • `defaultPolicy`              — only to customize conflict resolution
+ *   • `defineMutators` / `createTransaction` — only for custom mutators
+ * If you don't recognize one, you don't need it — the default path covers you.
  */
 // ── Consumer API ──────────────────────────────────────────────────────────
 // These are the only symbols external consumers should need from this path.
 // 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.*` —
 // `Ablo.Participant.Joined`, `Ablo.Participant.Manager`,
 // `Ablo.Participant.JoinOptions`, etc. Same dot-access shape as
 // `Ablo.Peer`, `Ablo.Claim`, `Ablo.Turn`. No flat re-exports.
-// Principal constructors — explicit factories for delegation paths
-// (`Ablo({ kind: 'agent', as: session({...}) })`). Function exports
-// because they're constructors, not types.
+// Advanced — most apps never import this. Principal constructors for
+// delegated agent paths (`Ablo({ kind: 'agent', as: session({...}) })`).
+// The default `Ablo({ schema, apiKey })` resolves identity from the key;
+// reach for these only when minting a delegated agent principal.
 export { session, agent } from './principal.js';
 import { Ablo } from './client/Ablo.js';
 export default Ablo;
-// Customer-owned storage adapter. Used only when Ablo Cloud coordinates
-// state while canonical rows remain in the customer's database. Runtime
-// helpers ship flat; type counterparts live under `Ablo.Source.*`
-// (`Ablo.Source.Operation`, `Ablo.Source.Commit.Params`, etc.).
+// Advanced — most apps never import this. Customer-owned storage adapter
+// for Data Source mode: only when Ablo Cloud coordinates state while
+// canonical rows stay in YOUR database. The default is Ablo-managed
+// storage — if you haven't deliberately chosen to keep your own DB
+// canonical, skip this entirely. Type counterparts live under
+// `Ablo.Source.*` (`Ablo.Source.Operation`, `Ablo.Source.Commit.Params`).
 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'`.
-// 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`,
-// `Ablo.Conflict.Policy` on the namespace.
+// `import Ablo from '@abloatai/ablo'`.
+// Advanced — most apps never import this. Conflict policy: `defaultPolicy`
+// (reject-on-stale) is already applied server-side, so you only import it
+// to COMPOSE a custom policy. Leave it alone and stale writes are rejected
+// safely by default. Type counterparts live under `Ablo.Conflict.*`.
 export { defaultPolicy } from './policy/index.js';
 // Typed error hierarchy — Stripe-style. One import gets every class
 // consumers need to discriminate failures (`e instanceof AbloX` or
@@ -66,8 +83,10 @@ export { SyncSessionError, AbloError, AbloAuthenticationError, AbloPermissionErr
 // Intents/UserMeta once in a `.d.ts` via `declare global { interface AbloSync
 // { ... } }`. Resolver types live under the `Ablo` namespace —
 // `Ablo.ResolveSchema`, `Ablo.ResolvePresence`, etc. — pure type-level.
-// Custom mutators — runtime entry point only.
-// Type counterparts moved to the `Ablo` namespace:
+// Advanced — most apps never import this. Custom (Zero-style) mutators:
+// `ablo.<model>.create/update/delete` already covers normal writes. Reach
+// for `defineMutators` only when you need a named, multi-step mutation with
+// custom undo. Type counterparts live under the `Ablo` namespace:
 //   Ablo.Mutator.Fn, Ablo.Transaction
 //   Ablo.Mutator.UndoEntry, Ablo.Mutator.InverseOp
 //   Ablo.Query, Ablo.QueryBatch, Ablo.QueryBatchResult
@@ -79,4 +98,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/policy/types.d.ts

@@ -29,6 +29,16 @@ export interface StaleContextConflict extends ConflictBase {
     readonly readAt: number;
     /** Most recent delta id on the target. */
     readonly observedSyncId: number;
+    /**
+     * The fields whose concurrent change triggered this conflict — the
+     * intersection of the committer's written fields and the columns a
+     * newer delta touched. Empty array means the conflicting delta was a
+     * whole-entity change (CREATE/DELETE, or a pre-`changed_fields`
+     * legacy delta), which conflicts with any write. Lets a policy decide
+     * at field granularity, e.g. allow when the only collision is on a
+     * cosmetic field. See `docs/internal/per-field-conflict-detection.md`.
+     */
+    readonly conflictingFields?: readonly string[];
 }
 export interface IntentHeldConflict extends ConflictBase {
     readonly kind: 'intent_held';

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({
@@ -18,8 +18,8 @@
  * participant layer handles attenuation.
  *
  * These are pure — no I/O, no hidden state. If the shape ever grows a
- * required field (say, a Biscuit scope hint), the helper is the one
- * place to flag migrations.
+ * required field (say, a scope hint for the restricted key), the helper
+ * is the one place to flag migrations.
  */
 import type { AgentRef, SessionRef } from './types/streams.js';
 /**

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({
@@ -18,8 +18,8 @@
  * participant layer handles attenuation.
  *
  * These are pure — no I/O, no hidden state. If the shape ever grows a
- * required field (say, a Biscuit scope hint), the helper is the one
- * place to flag migrations.
+ * required field (say, a scope hint for the restricted key), the helper
+ * is the one place to flag migrations.
  */
 /**
  * Build a `SessionRef` from the identifiers your auth system already

package/dist/query/client.d.ts

@@ -22,13 +22,14 @@ export interface PostQueryOptions {
     /** Timeout in ms for the fetch request. Default: 30000. */
     fetchTimeout?: number;
     /**
-     * Capability token (Biscuit) to attach as `Authorization: Bearer <token>`.
-     * Required for Node consumers (agent-worker, server-side tests) that
-     * have no session cookie to ride. Browser consumers can omit this and
-     * fall back to `credentials: 'include'`. When both are present the
-     * server prefers the Bearer header (see `agentTokenProvider` in
+     * Bearer credential — a restricted (`rk_`) API key — attached as
+     * `Authorization: Bearer <token>`. Required for Node consumers
+     * (agent-worker, server-side tests) that have no session cookie to
+     * ride. Browser consumers can omit this and fall back to
+     * `credentials: 'include'`. When both are present the server prefers
+     * the Bearer header (see `apiKeyProvider` in
      * `apps/sync-server/src/auth`), so passing the token in browser code
-     * is harmless.
+     * is harmless. (Field name predates the Biscuit→opaque-key migration.)
      */
     capabilityToken?: string;
 }

package/dist/react/AbloProvider.d.ts

@@ -29,8 +29,29 @@ import { type SyncStoreContract } from './context.js';
  *     only when `userId` / account scope / `url` change. React
  *     Strict Mode double-mount does not leak a second WebSocket.
  */
+/**
+ * Props for `<AbloProvider>`.
+ *
+ * The default path is one prop:
+ *
+ * ```tsx
+ * <AbloProvider schema={schema}>
+ *   <App />
+ * </AbloProvider>
+ * ```
+ *
+ * That's it for most apps — the provider resolves identity, account
+ * scope, and realtime permissions from auth. `userId`/`apiKey`/`url`
+ * are situational; the `bootstrapMode`, `persistence`, and `fallback`
+ * props are opt-in tuning; and the block tagged "Optional DI (advanced)"
+ * below is escape-hatch wiring for tests and platform builders — if you
+ * don't recognize a prop there, you don't need it.
+ */
 export interface AbloProviderProps<R extends SchemaRecord = SchemaRecord> {
-    /** Schema from `defineSchema()`. Determines the typed hook surface. */
+    /**
+     * Schema from `defineSchema()`. Determines the typed hook surface.
+     * This is the only prop most apps pass — start here.
+     */
     schema: Schema<R>;
     /**
      * WebSocket URL of the sync server (`wss://...` or `ws://...`).
@@ -103,6 +124,28 @@ export interface AbloProviderProps<R extends SchemaRecord = SchemaRecord> {
      * for the full semantics.
      */
     persistence?: AbloPersistence;
+    /**
+     * How aggressively this provider pulls baseline state at startup.
+     *
+     *  - `'full'` (default): pull every delta in the configured sync
+     *    groups before the engine reports ready — a local replica of the
+     *    org's tenant plane. Right for collaborative editors and any page
+     *    that reads a lot of shared state.
+     *  - `'none'`: open the connection and process live deltas only — no
+     *    baseline fetch. Reads round-trip via `ablo.<model>.retrieve(...)`
+     *    and subscriptions populate the pool lazily. Right for read-light
+     *    pages (a mostly-static dashboard, a settings screen) that don't
+     *    want to download the whole org to render.
+     *
+     * Note: `'none'` still opens the realtime connection — it skips the
+     * baseline pull, not the socket. A fully connection-free mode for
+     * pages that do zero multiplayer is a separate follow-up (the socket
+     * open lives inside `engine.ready()`, so deferring it needs
+     * engine-level lazy-connect support, not just a provider prop).
+     *
+     * Mirrors `AbloOptions.bootstrapMode`. Changing it rotates the engine.
+     */
+    bootstrapMode?: 'full' | 'none';
     /**
      * Rendered in place of `children` during the *first* bootstrap pass —
      * while the engine is actively transitioning from `initial` →

package/dist/react/AbloProvider.js

@@ -32,7 +32,7 @@ function createErrorEmitter() {
     };
 }
 export function AbloProvider(props) {
-    const { schema, url = 'wss://mesh.ablo.finance', userId, teamIds, apiKey, preventUnsavedChanges, onSessionExpired, onError, observability, logger, mutationExecutor, mutationDispatcher, sessionErrorDetector, onlineStatus, configOverrides, syncGroups, bootstrapBaseUrl, maxPoolSize, persistence, fallback = _jsx(DefaultFallback, {}), children, } = props;
+    const { schema, url = 'wss://mesh.ablo.finance', userId, teamIds, apiKey, preventUnsavedChanges, onSessionExpired, onError, observability, logger, mutationExecutor, mutationDispatcher, sessionErrorDetector, onlineStatus, configOverrides, syncGroups, bootstrapBaseUrl, maxPoolSize, persistence, bootstrapMode, fallback = _jsx(DefaultFallback, {}), children, } = props;
     // Account scope is no longer accepted from props. The engine learns
     // it from auth (capability token) at bootstrap and we read it back
     // out of `_store.orgId` once `engine.ready()` resolves.
@@ -62,6 +62,7 @@ export function AbloProvider(props) {
     const engineKey = JSON.stringify({
         userId: userId ?? null,
         url,
+        bootstrapMode: bootstrapMode ?? null,
     });
     const [engineState, setEngineState] = useState({ key: engineKey, engine: null });
     // Keep a ref to the current engine key so the rotation effect can
@@ -89,6 +90,7 @@ export function AbloProvider(props) {
             bootstrapBaseUrl,
             maxPoolSize,
             persistence,
+            ...(bootstrapMode ? { bootstrapMode } : {}),
             autoStart: false,
         };
         const engine = Ablo(engineOptions);

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/>}>

package/dist/react/useCurrentUserId.js

@@ -27,7 +27,7 @@ export function useCurrentUserId() {
     if (!ctx) {
         throw new AbloValidationError('useCurrentUserId: no <AbloProvider> mounted above this component. ' +
             'Wrap your tree with <AbloProvider ...> from ' +
-            '@ablo/sync-engine/react.', { code: 'no_ablo_provider' });
+            '@abloatai/ablo/react.', { code: 'no_ablo_provider' });
     }
     return ctx.currentUserId;
 }

package/dist/react/useErrorListener.js

@@ -25,7 +25,7 @@ export function useErrorListener(listener) {
     const ctx = useContext(AbloInternalContext);
     if (!ctx) {
         throw new AbloValidationError('useErrorListener: no <AbloProvider> mounted above this component. ' +
-            'Wrap your tree with <AbloProvider ...> from @ablo/sync-engine/react.', { code: 'no_ablo_provider' });
+            'Wrap your tree with <AbloProvider ...> from @abloatai/ablo/react.', { code: 'no_ablo_provider' });
     }
     // Stash the latest callback in a ref so the effect subscription
     // stays stable across renders. Matches the `useEventCallback`

package/dist/react/useMutate.d.ts

@@ -13,7 +13,7 @@ type GlobalMutateActions<K extends string> = ResolveSchema extends Schema ? K ex
  *
  * @example
  * import { schema } from '@ablo/schema';
- * import { useMutate } from '@ablo/sync-engine/react';
+ * import { useMutate } from '@abloatai/ablo/react';
  *
  * const tasks = useMutate(schema, 'tasks');
  *

package/dist/react/useMutationFailureListener.js

@@ -25,7 +25,7 @@ export function useMutationFailureListener(listener) {
     const ctx = useContext(AbloInternalContext);
     if (!ctx) {
         throw new AbloValidationError('useMutationFailureListener: no <AbloProvider> mounted above this component. ' +
-            'Wrap your tree with <AbloProvider ...> from @ablo/sync-engine/react.', { code: 'no_ablo_provider' });
+            'Wrap your tree with <AbloProvider ...> from @abloatai/ablo/react.', { code: 'no_ablo_provider' });
     }
     const ref = useRef(listener);
     ref.current = listener;

package/dist/react/useReader.d.ts

@@ -21,7 +21,7 @@ type GlobalReaderActions<K extends string> = ResolveSchema extends Schema ? K ex
  *
  * @example
  * import { schema } from '@ablo/schema';
- * import { useReader } from '@ablo/sync-engine/react';
+ * import { useReader } from '@abloatai/ablo/react';
  *
  * function useTaskMutations() {
  *   const read = useReader(schema, 'tasks');

package/dist/schema/field.d.ts

@@ -6,7 +6,7 @@
  * survives `.optional()`, `.nullable()`, and `.default()` chain calls.
  *
  * Usage:
- *   import { field } from '@ablo/sync-engine/schema';
+ *   import { field } from '@abloatai/ablo/schema';
  *
  *   const tasks = model({
  *     title: field.string(),

package/dist/schema/field.js

@@ -6,7 +6,7 @@
  * survives `.optional()`, `.nullable()`, and `.default()` chain calls.
  *
  * Usage:
- *   import { field } from '@ablo/sync-engine/schema';
+ *   import { field } from '@abloatai/ablo/schema';
  *
  *   const tasks = model({
  *     title: field.string(),

package/dist/schema/index.d.ts

@@ -1,11 +1,11 @@
 /**
- * @ablo/sync-engine/schema — Schema Definition DSL
+ * @abloatai/ablo/schema — Schema Definition DSL
  *
  * Define your data models with Zod. Types are inferred automatically.
  *
  * ```ts
  * import { z } from 'zod';
- * import { defineSchema, model, relation } from '@ablo/sync-engine/schema';
+ * import { defineSchema, model, relation } from '@abloatai/ablo/schema';
  *
  * export const schema = defineSchema({
  *   tasks: model({