@abloatai/ablo 0.5.1 → 0.7.0

package/dist/policy/types.d.ts

@@ -48,6 +48,14 @@ export interface IntentHeldConflict extends ConflictBase {
     readonly entityId: string;
     /** Holder's intent expiry (ms since epoch). */
     readonly expiresAt: number;
+    /**
+     * The committer's granted capability operations (the key's allowlist). A
+     * policy is a pure function of the conflict value, so it can only authorize
+     * on what's carried here — this is what lets a policy express "preempt iff
+     * the committer holds `intent.preempt`" (see `capabilityPreemptPolicy`).
+     * Empty for a human session with no allowlist.
+     */
+    readonly committerOperations: readonly string[];
 }
 /**
  * The discriminated union the policy receives. Switch on `.kind` to
@@ -61,6 +69,20 @@ export type ConflictDecision = {
 } | {
     readonly action: 'allow';
     readonly note?: string;
+}
+/**
+ * Evict the current holder and grant the target to the committer. Only
+ * meaningful for an `intent_held` conflict at claim time (`intent_begin`):
+ * the holder receives an `intent_lost` (reason `'preempted'`) and the
+ * preemptor takes the lease, jumping ahead of any FIFO waiters. This is the
+ * authorization seam for preemption — a policy returns `preempt` only for a
+ * committer it deems higher-priority (e.g. a supervisor over its sub-agents,
+ * or an identity holding a preempt capability). At commit time there is no
+ * holder to evict, so a `preempt` decision there is treated as `allow`.
+ */
+ | {
+    readonly action: 'preempt';
+    readonly reason?: string;
 };
 /**
  * Pluggable decision function. Sync or async.
@@ -81,4 +103,13 @@ export type ConflictPolicy = (conflict: Conflict) => ConflictDecision | Promise<
  * intent-conflicting write through.
  */
 export declare const defaultPolicy: ConflictPolicy;
+/**
+ * Capability-gated preemption. An `intent_held` conflict is PREEMPTED when the
+ * committer holds the `intent.preempt` operation in its capability allowlist
+ * (the holder is evicted, the committer takes the lease); everything else falls
+ * back to `defaultPolicy` (reject). Opt-in — wire it as a `conflictPolicies`
+ * global to let a privileged identity jump a held entity without a bespoke
+ * policy. The authorization is the capability, not an identity string.
+ */
+export declare const capabilityPreemptPolicy: ConflictPolicy;
 export {};

package/dist/policy/types.js

@@ -15,3 +15,18 @@ export const defaultPolicy = (conflict) => ({
     action: 'reject',
     reason: conflict.kind === 'stale_context' ? 'stale_context' : 'intent_conflict',
 });
+/**
+ * Capability-gated preemption. An `intent_held` conflict is PREEMPTED when the
+ * committer holds the `intent.preempt` operation in its capability allowlist
+ * (the holder is evicted, the committer takes the lease); everything else falls
+ * back to `defaultPolicy` (reject). Opt-in — wire it as a `conflictPolicies`
+ * global to let a privileged identity jump a held entity without a bespoke
+ * policy. The authorization is the capability, not an identity string.
+ */
+export const capabilityPreemptPolicy = (conflict) => {
+    if (conflict.kind === 'intent_held' &&
+        conflict.committerOperations.includes('intent.preempt')) {
+        return { action: 'preempt', reason: 'capability:intent.preempt' };
+    }
+    return defaultPolicy(conflict);
+};

package/dist/query/types.d.ts

@@ -135,7 +135,7 @@ export interface QueryBatchResult {
      */
     results: unknown[];
     /**
-     * Server watermark observed after the batch ran. Public resource reads
+     * Server watermark observed after the batch ran. Public model reads
      * expose this as `stamp` and callers thread it into `commits.create({
      * readAt })` to reject stale writes.
      */

package/dist/react/AbloProvider.d.ts

@@ -114,7 +114,19 @@ export interface AbloProviderProps<R extends SchemaRecord = SchemaRecord> {
     sessionErrorDetector?: SessionErrorDetector;
     onlineStatus?: OnlineStatusProvider;
     configOverrides?: SyncEngineConfig;
+    /**
+     * Raw sync-group strings for the initial connection. Prefer {@link scope} —
+     * the model form (`{ decks: deckId }`) that the engine resolves through the
+     * schema's `scope`, so you never hand-write a `deck:<id>` string. Both merge.
+     */
     syncGroups?: string[];
+    /**
+     * Model-form connection scope: `{ decks: deckId, documents: documentId }` or
+     * entity refs. Resolved through the schema's per-model `scope` into group
+     * strings (so typename `SlideDeck` → `deck:<id>`), unioned with {@link syncGroups}.
+     * Memoize the object if it's derived, to avoid rotating the engine each render.
+     */
+    scope?: ParticipantScope;
     bootstrapBaseUrl?: string;
     maxPoolSize?: number;
     /**
@@ -212,7 +224,7 @@ export declare function useParticipant(opts: UseParticipantOptions): UseParticip
 /**
  * Returns the raw `SyncEngine` proxy. Typically you want the typed
  * hooks (`useQuery`, `useOne`, `useMutate`) — this is for rare cases
- * where you need direct access (e.g., `sync.tasks.subscribe(cb)`).
+ * where you need direct access (e.g., `sync.tasks.onChange(cb)`).
  *
  * The generic parameter narrows the return type to your schema's
  * model record so call sites get typed `sync.tasks.findMany()` /

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, bootstrapMode, 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, scope, 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.
@@ -86,7 +86,11 @@ export function AbloProvider(props) {
             mutationExecutor,
             mutationDispatcher,
             configOverrides,
-            syncGroups,
+            // Union raw strings with model-form `scope` resolved through the schema,
+            // so `scope={{ decks: id }}` becomes `deck:<id>` via the model's `scope`.
+            syncGroups: scope
+                ? [...(syncGroups ?? []), ...resolveParticipantSyncGroups(scope, schema)]
+                : syncGroups,
             bootstrapBaseUrl,
             maxPoolSize,
             persistence,
@@ -251,7 +255,11 @@ export function useParticipant(opts) {
     const ctx = useContext(AbloInternalContext);
     const engine = ctx?.engine ?? null;
     const { paused = false } = opts;
-    const scopeKey = JSON.stringify(resolveParticipantSyncGroups(opts.scope).sort());
+    // Resolve the model-form scope ({ decks: id } / refs) THROUGH the schema, so a
+    // model's declared `scope` kind is honored (typename `SlideDeck` → `deck:<id>`,
+    // not the `type:id` string fallback). Schema appears once the engine is ready;
+    // until then refs resolve by convention, then re-resolve when it arrives.
+    const scopeKey = JSON.stringify(resolveParticipantSyncGroups(opts.scope, engine?.schema).sort());
     const scopedSyncGroups = useMemo(() => JSON.parse(scopeKey), [scopeKey]);
     const [claimError, setClaimError] = useState(null);
     const [claimConnected, setClaimConnected] = useState(false);
@@ -326,10 +334,10 @@ export function useParticipant(opts) {
         }
         setPeers(participant.presence.others);
         setClaims(participant.intents.others);
-        const unsubPresence = participant.presence.subscribe(() => {
+        const unsubPresence = participant.presence.onChange(() => {
             setPeers(participant.presence.others);
         });
-        const unsubIntents = participant.intents.subscribe(() => {
+        const unsubIntents = participant.intents.onChange(() => {
             setClaims(participant.intents.others);
         });
         return () => {
@@ -347,7 +355,7 @@ export function useParticipant(opts) {
 /**
  * Returns the raw `SyncEngine` proxy. Typically you want the typed
  * hooks (`useQuery`, `useOne`, `useMutate`) — this is for rare cases
- * where you need direct access (e.g., `sync.tasks.subscribe(cb)`).
+ * where you need direct access (e.g., `sync.tasks.onChange(cb)`).
  *
  * The generic parameter narrows the return type to your schema's
  * model record so call sites get typed `sync.tasks.findMany()` /

package/dist/react/context.d.ts

@@ -85,14 +85,14 @@ export interface SyncReactContext {
      * The stored reference is untyped here (`Schema` with default
      * parameters) because the React context is a single runtime value
      * shared by every hook. The compile-time types flow from the
-     * consumer's `declare global { interface AbloSync { Schema: ... } }`
+     * consumer's `declare module '@abloatai/ablo' { interface Register { Schema: ... } }`
      * augmentation — see `src/types/global.ts`.
      */
     schema?: Schema;
     /**
      * Optional presence source. When set, `usePresence()` returns this
      * value cast to the consumer's `ResolvePresence` type (declared via
-     * `interface AbloSync { Presence: ... }`). The SDK doesn't own a
+     * `interface Register { Presence: ... }`). The SDK doesn't own a
      * presence wire format — consumers plug whatever backs their cursors,
      * status, or activity state (a MobX store, a Zustand slice, a custom
      * subscription). The typed-global gives it a call-site-ergonomic
@@ -104,7 +104,7 @@ export interface SyncReactContext {
      * plug a function that turns an intent claim into a handle they
      * control (WebSocket send, optimistic local update, whatever).
      * `useIntent(name)` returns a typed invoker for the named intent
-     * from `interface AbloSync { Intents: ... }`.
+     * from `interface Register { Intents: ... }`.
      */
     beginIntent?: (intentName: string, claim: unknown) => unknown;
 }
@@ -125,7 +125,7 @@ export interface SyncProviderProps {
     /**
      * Optional schema. Wire this when you want compatibility string-keyed hooks
      * (`useQuery('tasks')`) — the schema type also narrows via the
-     * consumer's global `AbloSync` declaration. Omit to keep hooks on
+     * consumer's `Register` registration. Omit to keep hooks on
      * their legacy `(schema, modelKey, …)` signatures.
      */
     schema?: Schema;

package/dist/react/index.d.ts

@@ -15,8 +15,8 @@
  * Data hooks:
  *   useAblo((ablo) => ablo.tasks.retrieve(id)) — primary React read API
  *   useAblo()                                  — typed client for callbacks/effects
- *   useQuery/useOne/useReader/useMutate        — compatibility helpers for older
- *                                                string-keyed integrations
+ *                                                (reads: ablo.<model>.retrieve/list;
+ *                                                 writes: ablo.<model>.create/update/delete)
  *   useMutators(defs, opts?)                   — Zero-style custom mutators
  *   useUndoScope(name)                         — per-surface undo/redo
  *
@@ -53,9 +53,8 @@ export { useErrorListener } from './useErrorListener.js';
 export { useMutationFailureListener, type MutationFailurePayload, } from './useMutationFailureListener.js';
 export { useCurrentUserId } from './useCurrentUserId.js';
 export { useReactive } from './useReactive.js';
-export { useQuery, useOne, type QueryOptions } from './useQuery.js';
-export { useMutate, type MutateActions } from './useMutate.js';
-export { useReader, type ReaderActions, type ReaderFindOptions } from './useReader.js';
+export type { MutateActions } from '../mutators/mutateActions.js';
+export type { ReaderActions, ReaderFindOptions } from '../mutators/readerActions.js';
 export { useMutators, type MutatorInvokers, type InvokerFor, type UseMutatorsOptions, } from './useMutators.js';
 export { useUndoScope, type UseUndoScopeResult } from './useUndoScope.js';
 export { useAblo, type UseAbloHydratedModelResult, type UseAbloModelOptions, type UseAbloModelResult, } from './useAblo.js';

package/dist/react/index.js

@@ -15,8 +15,8 @@
  * Data hooks:
  *   useAblo((ablo) => ablo.tasks.retrieve(id)) — primary React read API
  *   useAblo()                                  — typed client for callbacks/effects
- *   useQuery/useOne/useReader/useMutate        — compatibility helpers for older
- *                                                string-keyed integrations
+ *                                                (reads: ablo.<model>.retrieve/list;
+ *                                                 writes: ablo.<model>.create/update/delete)
  *   useMutators(defs, opts?)                   — Zero-style custom mutators
  *   useUndoScope(name)                         — per-surface undo/redo
  *
@@ -59,14 +59,10 @@ export { useCurrentUserId } from './useCurrentUserId.js';
 // lower-level `useSyncExternalStore`. Hides the cached-snapshot
 // contract and handles default structural equality for arrays.
 export { useReactive } from './useReactive.js';
-// ── Data hooks ─────────────────────────────────────────────────────
-export { useQuery, useOne } from './useQuery.js';
-export { useMutate } from './useMutate.js';
-export { useReader } from './useReader.js';
 export { useMutators, } from './useMutators.js';
 export { useUndoScope } from './useUndoScope.js';
 export { useAblo, } from './useAblo.js';
-// ── Presence + intent (typed via AbloSync global augmentation) ─────
+// ── Presence + intent (typed via Register module augmentation) ─────
 export { usePresence } from './usePresence.js';
 export { useIntent } from './useIntent.js';
 // ── ModelScope re-export ───────────────────────────────────────────

package/dist/react/useAblo.d.ts

@@ -1,10 +1,10 @@
-import type { Ablo, ResourceIntent } from '../client/Ablo.js';
+import type { Ablo, ModelClaim } from '../client/Ablo.js';
 import type { ModelOperations } from '../client/createModelProxy.js';
 import type { SchemaRecord } from '../schema/schema.js';
 import type { ResolveSchema } from '../types/global.js';
 /**
  * Resolved schema-record type for the consumer's app. Reads the
- * `AbloSync` global augmentation if declared, falls back to the
+ * `Register` module augmentation if declared, falls back to the
  * loose `SchemaRecord` if not. This lets `useAblo()` produce a
  * fully typed engine handle without the consumer having to pass
  * `<(typeof schema)['models']>` at every call site.
@@ -12,12 +12,12 @@ import type { ResolveSchema } from '../types/global.js';
 type DefaultModels = ResolveSchema extends {
     models: infer M;
 } ? M extends SchemaRecord ? M : SchemaRecord : SchemaRecord;
-type ModelResourceSelector<R extends SchemaRecord, T, C> = (ablo: Ablo<R>) => ModelOperations<T, C>;
+type ModelClientSelector<R extends SchemaRecord, T, C> = (ablo: Ablo<R>) => ModelOperations<T, C>;
 type AbloSelector<R extends SchemaRecord, T> = (ablo: Ablo<R>) => T;
 export interface UseAbloModelOptions<T> {
     /**
      * Initial row, usually from a Server Component or loader. The hook returns it
-     * until the model resource has a newer row in the local pool.
+     * until the model client has a newer row in the local pool.
      */
     readonly initial?: T;
 }
@@ -25,9 +25,9 @@ export interface UseAbloModelResult<T> {
     /** Current row for the id, or `initial` until the row has hydrated. */
     readonly data: T | undefined;
     /** Active work claims on this model row. */
-    readonly intents: readonly ResourceIntent[];
+    readonly claims: readonly ModelClaim[];
     /** Convenience flag for disabling UI while another participant is active. */
-    readonly busy: boolean;
+    readonly claimed: boolean;
 }
 export type UseAbloHydratedModelResult<T> = Omit<UseAbloModelResult<T>, 'data'> & {
     readonly data: T;
@@ -36,20 +36,20 @@ export type UseAbloHydratedModelResult<T> = Omit<UseAbloModelResult<T>, 'data'>
  * useAblo — access the typed engine instance, or subscribe to a specific
  * `ablo.<model>` row from inside an `<AbloProvider>` subtree.
  *
- * Zero-arg when the consumer declares the `AbloSync` global
- * augmentation (`declare global { interface AbloSync { Schema:
+ * Zero-arg when the consumer declares the `Register` global
+ * augmentation (`declare module '@abloatai/ablo' { interface Register { Schema:
  * typeof schema } }`). The default generic resolves through
  * `ResolveSchema['models']` so call sites stay clean:
  *
  * ```ts
- * // With AbloSync augmentation (recommended):
+ * // With Register augmentation (recommended):
  * const ablo = useAblo();
  * if (!ablo) return <Loading />;
  * const docs = await ablo.documents.load({ where: { id } });
  *
  * // Reactive selector:
  * const doc = useAblo((ablo) => ablo.documents.retrieve(id)) ?? serverDoc;
- * const intents = useAblo((ablo) => ablo.intents.list({ resource: 'documents', id }));
+ * const active = useAblo((ablo) => ablo.documents.claimState(id));
  *
  * // Without augmentation, pass the schema generic:
  * const ablo = useAblo<(typeof schema)['models']>();
@@ -61,12 +61,12 @@ export type UseAbloHydratedModelResult<T> = Omit<UseAbloModelResult<T>, 'data'>
  */
 export declare function useAblo<R extends SchemaRecord = DefaultModels>(): Ablo<R> | null;
 export declare function useAblo<R extends SchemaRecord = DefaultModels, T = unknown>(select: AbloSelector<R, T>): T | undefined;
-export declare function useAblo<T, C>(resource: ModelOperations<T, C>, id: string, options: UseAbloModelOptions<T> & {
+export declare function useAblo<T, C>(modelClient: ModelOperations<T, C>, id: string, options: UseAbloModelOptions<T> & {
     readonly initial: T;
 }): UseAbloHydratedModelResult<T>;
-export declare function useAblo<R extends SchemaRecord = DefaultModels, T = Record<string, unknown>, C = unknown>(select: ModelResourceSelector<R, T, C>, id: string, options: UseAbloModelOptions<T> & {
+export declare function useAblo<R extends SchemaRecord = DefaultModels, T = Record<string, unknown>, C = unknown>(select: ModelClientSelector<R, T, C>, id: string, options: UseAbloModelOptions<T> & {
     readonly initial: T;
 }): UseAbloHydratedModelResult<T>;
-export declare function useAblo<T, C>(resource: ModelOperations<T, C>, id: string, options?: UseAbloModelOptions<T>): UseAbloModelResult<T>;
-export declare function useAblo<R extends SchemaRecord = DefaultModels, T = Record<string, unknown>, C = unknown>(select: ModelResourceSelector<R, T, C>, id: string, options?: UseAbloModelOptions<T>): UseAbloModelResult<T>;
+export declare function useAblo<T, C>(modelClient: ModelOperations<T, C>, id: string, options?: UseAbloModelOptions<T>): UseAbloModelResult<T>;
+export declare function useAblo<R extends SchemaRecord = DefaultModels, T = Record<string, unknown>, C = unknown>(select: ModelClientSelector<R, T, C>, id: string, options?: UseAbloModelOptions<T>): UseAbloModelResult<T>;
 export {};

package/dist/react/useAblo.js

@@ -1,20 +1,20 @@
 'use client';
 import { useContext, useEffect, useState } from 'react';
 import { AbloInternalContext } from './internalContext.js';
-import { getModelResourceMeta } from '../client/createModelProxy.js';
+import { getModelClientMeta } from '../client/createModelProxy.js';
 import { Model, modelAsRow } from '../Model.js';
 import { useReactive } from './useReactive.js';
-const EMPTY_INTENTS = Object.freeze([]);
-function readModelResult(engine, resource, id, initial) {
-    if (!resource || id === undefined) {
-        return { data: initial, intents: EMPTY_INTENTS, busy: false };
+const EMPTY_CLAIMS = Object.freeze([]);
+function readModelResult(engine, modelClient, id, initial) {
+    if (!modelClient || id === undefined) {
+        return { data: initial, claims: EMPTY_CLAIMS, claimed: false };
     }
-    const data = snapshotValue(resource.retrieve(id) ?? initial);
-    const meta = getModelResourceMeta(resource);
-    const intents = meta && engine
-        ? engine.intents.list({ resource: meta.key, id })
-        : EMPTY_INTENTS;
-    return { data, intents, busy: intents.length > 0 };
+    const data = snapshotValue(modelClient.retrieve(id) ?? initial);
+    const meta = getModelClientMeta(modelClient);
+    const claims = meta && engine
+        ? engine.intents.list({ model: meta.key, id })
+        : EMPTY_CLAIMS;
+    return { data, claims, claimed: claims.length > 0 };
 }
 function snapshotValue(value) {
     if (value instanceof Model) {
@@ -25,39 +25,39 @@ function snapshotValue(value) {
     }
     return value;
 }
-export function useAblo(resourceOrSelect, id, options) {
+export function useAblo(modelOrSelect, id, options) {
     const ctx = useContext(AbloInternalContext);
     const engine = ctx?.engine ?? null;
     const initial = options?.initial;
-    const hasSelection = resourceOrSelect !== undefined;
-    const isSelectorOnly = typeof resourceOrSelect === 'function' && id === undefined;
-    const resource = typeof resourceOrSelect === 'function' && id !== undefined
+    const hasSelection = modelOrSelect !== undefined;
+    const isSelectorOnly = typeof modelOrSelect === 'function' && id === undefined;
+    const modelClient = typeof modelOrSelect === 'function' && id !== undefined
         ? engine
-            ? resourceOrSelect(engine)
+            ? modelOrSelect(engine)
             : undefined
-        : typeof resourceOrSelect === 'function'
+        : typeof modelOrSelect === 'function'
             ? undefined
-            : resourceOrSelect;
-    const [intentVersion, setIntentVersion] = useState(0);
+            : modelOrSelect;
+    const [claimVersion, setClaimVersion] = useState(0);
     useEffect(() => {
         if (!engine || !hasSelection)
             return;
-        return engine.intents.subscribe(() => setIntentVersion((version) => version + 1));
+        return engine.intents.onChange(() => setClaimVersion((version) => version + 1));
     }, [engine, hasSelection]);
     const selected = useReactive(() => {
-        void intentVersion;
-        if (!engine || !isSelectorOnly || typeof resourceOrSelect !== 'function') {
+        void claimVersion;
+        if (!engine || !isSelectorOnly || typeof modelOrSelect !== 'function') {
             return undefined;
         }
-        return snapshotValue(resourceOrSelect(engine));
+        return snapshotValue(modelOrSelect(engine));
     });
     const modelResult = useReactive(() => {
-        void intentVersion;
-        return readModelResult(engine, resource, id, initial);
+        void claimVersion;
+        return readModelResult(engine, modelClient, id, initial);
     });
     if (isSelectorOnly)
         return selected;
-    if (resourceOrSelect)
+    if (modelOrSelect)
         return modelResult;
     return engine;
 }

package/dist/react/useIntent.d.ts

@@ -5,8 +5,8 @@ import type { ResolveIntents } from '../types/global.js';
  * The consumer declares their intent vocabulary in the global:
  *
  * ```ts
- * declare global {
- *   interface AbloSync {
+ * declare module '@abloatai/ablo' {
+ *   interface Register {
  *     Intents: {
  *       editLayer: { slideId: string; layerId: string };
  *       generateWithAI: { entityId: string; tool: string };

package/dist/react/useIntent.js

@@ -8,8 +8,8 @@ import { AbloValidationError } from '../errors.js';
  * The consumer declares their intent vocabulary in the global:
  *
  * ```ts
- * declare global {
- *   interface AbloSync {
+ * declare module '@abloatai/ablo' {
+ *   interface Register {
  *     Intents: {
  *       editLayer: { slideId: string; layerId: string };
  *       generateWithAI: { entityId: string; tool: string };

package/dist/react/useMutators.d.ts

@@ -50,7 +50,7 @@ export interface UseMutatorsOptions<S extends Schema> {
 }
 /** Mutator invokers (explicit schema arg). */
 export declare function useMutators<S extends Schema, M extends MutatorDefs<S>>(schema: S, mutators: M, options?: UseMutatorsOptions<S>): MutatorInvokers<M>;
-/** Mutator invokers via the `AbloSync` global augmentation. Schema comes
+/** Mutator invokers via the `Register` module augmentation. Schema comes
  * from the `SyncProvider`'s context; the mutator tree is typed against
  * `ResolveSchema` at the call site. */
 export declare function useMutators<M extends ResolveSchema extends Schema ? MutatorDefs<ResolveSchema> : MutatorDefs<Schema>>(mutators: M, options?: UseMutatorsOptions<ResolveSchema extends Schema ? ResolveSchema : Schema>): MutatorInvokers<M>;

package/dist/react/usePresence.d.ts

@@ -2,7 +2,7 @@ import type { ResolvePresence } from '../types/global.js';
 /**
  * Read the consumer-supplied presence state with `ResolvePresence`d
  * typing — the shape the consumer declared in
- * `declare global { interface AbloSync { Presence: ... } }`.
+ * `declare module '@abloatai/ablo' { interface Register { Presence: ... } }`.
  *
  * The SDK doesn't own a presence wire format. Consumers plug whatever
  * backs their cursors, status, or activity (a MobX store, a custom
@@ -11,8 +11,8 @@ import type { ResolvePresence } from '../types/global.js';
  *
  * ```ts
  * // apps/your-app/src/ablo-sync.d.ts
- * declare global {
- *   interface AbloSync {
+ * declare module '@abloatai/ablo' {
+ *   interface Register {
  *     Presence: { cursor: { x: number; y: number } | null; status: 'away' | 'online' };
  *   }
  * }

package/dist/react/usePresence.js

@@ -3,7 +3,7 @@ import { useSyncContext } from './context.js';
 /**
  * Read the consumer-supplied presence state with `ResolvePresence`d
  * typing — the shape the consumer declared in
- * `declare global { interface AbloSync { Presence: ... } }`.
+ * `declare module '@abloatai/ablo' { interface Register { Presence: ... } }`.
  *
  * The SDK doesn't own a presence wire format. Consumers plug whatever
  * backs their cursors, status, or activity (a MobX store, a custom
@@ -12,8 +12,8 @@ import { useSyncContext } from './context.js';
  *
  * ```ts
  * // apps/your-app/src/ablo-sync.d.ts
- * declare global {
- *   interface AbloSync {
+ * declare module '@abloatai/ablo' {
+ *   interface Register {
  *     Presence: { cursor: { x: number; y: number } | null; status: 'away' | 'online' };
  *   }
  * }
@@ -35,7 +35,7 @@ export function usePresence() {
     // The runtime value is whatever the consumer passed to `SyncProvider`.
     // The type assertion reflects the consumer's declared global, which
     // the hook can't verify at runtime — but the consumer controls both
-    // ends (the global declaration and the provider prop) so this is a
+    // ends (the registration and the provider prop) so this is a
     // single-source-of-truth contract, not blind trust.
     return ctx.presence;
 }

package/dist/react/useUndoScope.d.ts

@@ -32,5 +32,5 @@ export interface UseUndoScopeResult<S extends Schema> {
 }
 /** Per-surface undo/redo (explicit schema arg). */
 export declare function useUndoScope<S extends Schema>(schema: S, name: string, options?: UndoScopeOptions): UseUndoScopeResult<S>;
-/** Per-surface undo/redo via the `AbloSync` global augmentation. */
+/** Per-surface undo/redo via the `Register` module augmentation. */
 export declare function useUndoScope(name: string, options?: UndoScopeOptions): UseUndoScopeResult<ResolveSchema extends Schema ? ResolveSchema : Schema>;

package/dist/schema/ddl.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Schema → Postgres DDL — the one pure SQL emitter shared by every consumer.
+ *
+ * `defineSchema(...)` (serialized to {@link SchemaJSON}) is the single source of
+ * truth; this module lowers it to ordered DDL strings. Both the hosted server
+ * (which applies it to Ablo-managed Postgres on `schema push`) and the
+ * `ablo migrate` CLI (which applies it to a customer's own Postgres) call these
+ * generators, so the SQL — column types, RLS, enum checks — is identical no
+ * matter who runs it. There is no second type map.
+ *
+ * Everything here is pure (returns strings; no DB, no I/O); the execution side
+ * (transaction + advisory lock) lives with each consumer because it's coupled
+ * to that consumer's Postgres client and error type.
+ *
+ *  - `generateProvisionPlan` — additive + idempotent (CREATE/ADD … IF NOT
+ *    EXISTS + RLS). Never loses data. The "create my tables" primitive.
+ *  - `generateMigrationPlan` — the destructive-aware counterpart driven by the
+ *    {@link diffSchema} step list (drops, renames, type casts, backfills).
+ */
+import type { SchemaJSON, ModelJSON } from './serialize.js';
+import type { MigrationStep, BackfillValue } from './diff.js';
+export interface ProvisionPlan {
+    /** The Postgres schema the tables live in (`app_<id>` or `public`). */
+    readonly appSchema: string;
+    /** Ordered, idempotent DDL statements. Safe to run repeatedly. */
+    readonly statements: readonly string[];
+}
+export interface MigrationPlan {
+    /** The app Postgres schema the DDL targets (`app_<id>` or `public`). */
+    readonly appSchema: string;
+    /** Ordered DDL statements (expand → contract). */
+    readonly statements: readonly string[];
+}
+/** Per-app schema name for an app (organization) id. */
+export declare function appSchemaName(organizationId: string): string;
+export declare function camelToSnake(identifier: string): string;
+/** Quote an identifier (defense-in-depth; inputs are already slug/snake). */
+export declare function q(identifier: string): string;
+export declare function sqlType(fieldType: ModelJSON['fields'][string]['type']): string;
+/**
+ * Build the additive, idempotent provisioning plan for an app. Pure — no DB
+ * access.
+ *
+ * `targetSchema` is where the tables live: the app's schema `app_<id>` on the
+ * shared tier, or `public` on a dedicated tenant's own database (where the DB
+ * itself is the isolation boundary). For `public` the `CREATE SCHEMA` is
+ * skipped (it always exists).
+ */
+export declare function generateProvisionPlan(schema: SchemaJSON, targetSchema: string): ProvisionPlan;
+/**
+ * Lower an ordered migration step list to DDL. `next` is the schema being pushed
+ * (the target column shapes are read from it), `prev` the active one (used to
+ * resolve the *old* table name on a model rename).
+ */
+export declare function generateMigrationPlan(steps: readonly MigrationStep[], opts: {
+    readonly prev: SchemaJSON | null;
+    readonly next: SchemaJSON;
+    readonly targetSchema: string;
+    /** Constant seed values that let a required-field add / made-required step
+     *  set NOT NULL on a non-empty table. Keyed by (model, field). */
+    readonly backfills?: readonly BackfillValue[];
+}): MigrationPlan;