@abloatai/ablo 0.3.0

package/dist/react/useSyncStatus.js

@@ -0,0 +1,76 @@
+'use client';
+import { useCallback } from 'react';
+import { useSyncContext } from './context.js';
+import { useReactive } from './useReactive.js';
+/**
+ * Reactive sync-status hook. Bridges MobX `store.syncStatus` +
+ * `store.isReady` into React via `useReactive` — concurrent-render
+ * safe and immune to the React #185 "getSnapshot should be cached"
+ * infinite-loop class of bugs.
+ *
+ * @example
+ * function StatusPill() {
+ *   const status = useSyncStatus();
+ *   switch (status.name) {
+ *     case 'initial':
+ *     case 'connecting':     return <Pill progress={status.name === 'connecting' ? status.progress : 0}>Loading…</Pill>;
+ *     case 'connected':      return status.hasUnsyncedChanges ? <Pill>Saving…</Pill> : null;
+ *     case 'reconnecting':   return <Pill title={status.reason}>Reconnecting…</Pill>;
+ *     case 'disconnected':   return <Pill title={status.reason}>Offline</Pill>;
+ *     case 'needs-auth':     return null;
+ *   }
+ * }
+ */
+export function useSyncStatus() {
+    const { store } = useSyncContext();
+    // `useReactive` tracks the MobX observables read inside deriveStatus
+    // (syncStatus.state/progress/pendingChanges/isSessionError/error +
+    // the computed isReady), caches the result by shape, and only
+    // notifies React when a variant transition actually occurs.
+    //
+    // Stabilize the closure on `store` identity so useReactive's
+    // swap-detection doesn't see a "swap" every render and unnecessarily
+    // re-subscribe its MobX reaction.
+    const compute = useCallback(() => deriveStatus(store), [store]);
+    return useReactive(compute, sameSnapshot);
+}
+/** Map the current store state into the discriminated union. */
+function deriveStatus(store) {
+    const { state, progress, pendingChanges, isSessionError, error } = store.syncStatus;
+    if (isSessionError) {
+        return { name: 'needs-auth' };
+    }
+    if (state === 'reconnecting') {
+        return { name: 'reconnecting', reason: error?.message };
+    }
+    if (state === 'offline') {
+        return { name: 'disconnected', reason: 'offline' };
+    }
+    if (state === 'error') {
+        return { name: 'disconnected', reason: error?.message };
+    }
+    if (store.isReady) {
+        return { name: 'connected', hasUnsyncedChanges: pendingChanges > 0 };
+    }
+    // state is 'idle' or 'syncing' and not yet ready — bootstrap underway.
+    if (state === 'idle' || state === 'syncing') {
+        return { name: 'connecting', progress };
+    }
+    return { name: 'initial' };
+}
+function sameSnapshot(a, b) {
+    if (a.name !== b.name)
+        return false;
+    switch (a.name) {
+        case 'initial':
+        case 'needs-auth':
+            return true;
+        case 'connecting':
+            return a.progress === b.progress;
+        case 'connected':
+            return a.hasUnsyncedChanges === b.hasUnsyncedChanges;
+        case 'reconnecting':
+        case 'disconnected':
+            return a.reason === b.reason;
+    }
+}

package/dist/react/useUndoScope.d.ts

@@ -0,0 +1,36 @@
+import type { Schema } from '../schema/schema.js';
+import type { UndoScope, UndoScopeOptions } from '../mutators/UndoManager.js';
+import type { ResolveSchema } from '../types/global.js';
+/**
+ * useUndoScope — per-surface undo/redo for mutator invocations.
+ *
+ * Zero deliberately does NOT ship a built-in undo API; consumers build one
+ * on top of mutation tracking. This is ours.
+ *
+ * Each named scope owns an independent undo/redo stack. Wire the returned
+ * `scope` into `useMutators(schema, mutators, { undoScope: scope })` and the
+ * invocations become recorded. `undo()` / `redo()` replay the inverses /
+ * forwards as new transactions that do NOT re-record (the manager pushes
+ * them between the two stacks explicitly).
+ *
+ * @example
+ * const { undo, redo, canUndo, canRedo, scope } = useUndoScope('deck-editor');
+ * const mutate = useMutators(schema, deckMutators, { undoScope: scope });
+ *
+ * // Cmd+Z handler
+ * useHotkey('mod+z', () => { if (canUndo) void undo(); });
+ */
+export interface UseUndoScopeResult<S extends Schema> {
+    /** Pass to `useMutators(..., { undoScope })` to enable recording. */
+    scope: UndoScope<S>;
+    undo: () => Promise<void>;
+    redo: () => Promise<void>;
+    canUndo: boolean;
+    canRedo: boolean;
+    /** Drop history. Use after sync errors / auth context changes. */
+    clear: () => void;
+}
+/** 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. */
+export declare function useUndoScope(name: string, options?: UndoScopeOptions): UseUndoScopeResult<ResolveSchema extends Schema ? ResolveSchema : Schema>;

package/dist/react/useUndoScope.js

@@ -0,0 +1,73 @@
+'use client';
+import { useEffect, useMemo, useState } from 'react';
+import { UndoManager } from '../mutators/UndoManager.js';
+import { useSyncContext } from './context.js';
+import { AbloValidationError } from '../errors.js';
+// Module-level weak registry: `SyncStoreContract` → `UndoManager`.
+// A single app wiring through one SyncProvider shares one manager across
+// every useUndoScope call, so scopes with the same name are identity-equal.
+// Storage erases the generic — `UndoManager<S>` is invariant in S, so
+// the WeakMap can't hold the precise type alongside the typed factory
+// signature. We re-assert at retrieval; the contract is "scope keys
+// are unique per-app and the schema is the same across every call
+// for that key."
+const managers = new WeakMap();
+function getManager(key, factory) {
+    let m = managers.get(key);
+    if (!m) {
+        // Generic-erasure boundary at storage. Concentrating the cast
+        // here so the retrieval path doesn't have to repeat it.
+        const created = factory();
+        managers.set(key, created);
+        m = created;
+    }
+    // Single typed cast at retrieval — `as UndoManager<S>` would be
+    // rejected (TS sees `UndoManager<Schema>` and `UndoManager<S>` as
+    // unrelated), but we're at the runtime/static schema-identity
+    // boundary the contract above pins.
+    return m;
+}
+export function useUndoScope(schemaOrName, nameOrOptions, maybeOptions) {
+    const { store, organizationId, schema: ctxSchema } = useSyncContext();
+    const isExplicit = typeof schemaOrName !== 'string';
+    const schema = isExplicit ? schemaOrName : ctxSchema;
+    const name = isExplicit ? nameOrOptions : schemaOrName;
+    const options = (isExplicit ? maybeOptions : nameOrOptions);
+    if (!schema) {
+        throw new AbloValidationError('useUndoScope: no schema available. Pass the schema as the first arg ' +
+            'or wire SyncProvider with a `schema` prop when using the zero-arg overload.', { code: 'undo_scope_schema_missing' });
+    }
+    const scope = useMemo(() => {
+        // Store is the identity for the manager — one per SyncProvider.
+        const manager = getManager(store, () => new UndoManager(schema, store, organizationId));
+        return manager.getScope(name, options);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [store, organizationId, name]);
+    // Local tick forces re-render after undo/redo/clear so canUndo/canRedo
+    // reflect the new stack sizes. The scope itself doesn't emit React-
+    // friendly notifications; callers that want cross-component reactivity
+    // can wire a mobx observable or custom event bus on top.
+    const [, setTick] = useState(0);
+    // Reset tick when scope identity changes (new store / new orgId).
+    useEffect(() => {
+        setTick(0);
+    }, [scope]);
+    const size = scope.size();
+    return {
+        scope,
+        undo: async () => {
+            await scope.undo();
+            setTick((t) => t + 1);
+        },
+        redo: async () => {
+            await scope.redo();
+            setTick((t) => t + 1);
+        },
+        canUndo: size.undo > 0,
+        canRedo: size.redo > 0,
+        clear: () => {
+            scope.clear();
+            setTick((t) => t + 1);
+        },
+    };
+}

package/dist/realtime/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Internal compatibility entrypoint for the schema-powered realtime client.
+ *
+ * Use this build for applications that need typed model proxies,
+ * subscriptions, presence, offline queueing, and a long-lived WebSocket.
+ */
+export { Ablo, computeFKDepthPriority } from '../client/Ablo.js';
+export type { AbloOptions, InternalAbloOptions, ModelCountOptions, ModelListOptions, ModelListScope, ModelLoadOptions, ModelOperations, } from '../client/Ablo.js';
+import { Ablo } from '../client/Ablo.js';
+export default Ablo;

package/dist/realtime/index.js

@@ -0,0 +1,9 @@
+/**
+ * Internal compatibility entrypoint for the schema-powered realtime client.
+ *
+ * Use this build for applications that need typed model proxies,
+ * subscriptions, presence, offline queueing, and a long-lived WebSocket.
+ */
+export { Ablo, computeFKDepthPriority } from '../client/Ablo.js';
+import { Ablo } from '../client/Ablo.js';
+export default Ablo;

package/dist/schema/field.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Schema Field Helpers
+ *
+ * Thin wrappers around Zod that add sync-engine metadata (type tag, indexed).
+ * Metadata is stored in `z.describe()` as a JSON-encoded string so it
+ * survives `.optional()`, `.nullable()`, and `.default()` chain calls.
+ *
+ * Usage:
+ *   import { field } from '@ablo/sync-engine/schema';
+ *
+ *   const tasks = model({
+ *     title: field.string(),
+ *     projectId: field.string().indexed(),     // fluent chain
+ *     priority: field.number().optional(),
+ *     status: field.enum(['todo', 'doing', 'done']),
+ *   });
+ *
+ * Or use Zod directly (no metadata, but still works):
+ *   import { z } from 'zod';
+ *
+ *   const tasks = model({
+ *     title: z.string(),
+ *   });
+ */
+import { z } from 'zod';
+/** Runtime metadata for a schema field, readable via `ModelDef.fields`. */
+export interface FieldMeta {
+    /** Sync-engine type tag (maps to storage/serialization hints). */
+    type: 'string' | 'number' | 'boolean' | 'date' | 'enum' | 'json';
+    /** Whether the field was marked optional via `.optional()` or `.nullable()`. */
+    isOptional: boolean;
+    /** Whether the field was marked indexed via `.indexed()`. */
+    isIndexed: boolean;
+    /** For enums: the allowed values. */
+    enumValues?: readonly string[];
+}
+/**
+ * Extract FieldMeta from a Zod schema. Returns null if no sync-engine
+ * metadata is attached (e.g., raw `z.string()` usage).
+ *
+ * Walks through `.optional()` and `.nullable()` wrappers to find the
+ * underlying description.
+ */
+export declare function getFieldMeta(schema: z.ZodType): FieldMeta | null;
+/**
+ * Fallback: infer FieldMeta directly from a raw Zod schema when no
+ * `field.*()` metadata was attached.
+ *
+ * Walks through `.optional()` / `.nullable()` / `.default()` wrappers
+ * to find the inner primitive, then maps Zod's `_def.typeName` to
+ * the sync-engine type tag. Used by `resolveFieldMeta` and by
+ * `model()` / `query()` at definition time.
+ *
+ * Kept as an internal helper rather than exported directly — the
+ * public API is `resolveFieldMeta`, which combines this fallback
+ * with the `getFieldMeta` fast path.
+ */
+export declare function inferFieldMetaFromZod(schema: z.ZodType): FieldMeta;
+/**
+ * Resolve FieldMeta for any Zod schema — whether it was built with
+ * `field.*()` (which attaches sync-engine metadata) or with raw Zod
+ * (which requires fallback inference from `_def.typeName`).
+ *
+ * This is the single public entry point for "given a Zod field, tell
+ * me its sync-engine type tag and optionality." Both `model()` and
+ * `query()` use it to populate their `fields` / `inputFields` maps at
+ * definition time, and the schema serializer reads those maps at
+ * serialization time.
+ *
+ * Contract: always returns a value. Never returns null. Unknown Zod
+ * types fall through to `'string'` — this is intentional and matches
+ * the existing behavior that was previously duplicated in
+ * `model.ts:inferMetaFromZod`.
+ */
+export declare function resolveFieldMeta(schema: z.ZodType): FieldMeta;
+export declare const field: {
+    /** String field */
+    readonly string: () => z.ZodString & {
+        indexed(): z.ZodString;
+    };
+    /** Number field */
+    readonly number: () => z.ZodNumber & {
+        indexed(): z.ZodNumber;
+    };
+    /** Boolean field */
+    readonly boolean: () => z.ZodBoolean & {
+        indexed(): z.ZodBoolean;
+    };
+    /** Date field */
+    readonly date: () => z.ZodDate & {
+        indexed(): z.ZodDate;
+    };
+    /** Enum field with constrained string values */
+    readonly enum: <const T extends readonly [string, ...string[]]>(values: T) => z.ZodEnum<{ [k_1 in T[number]]: k_1; } extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never> & {
+        indexed(): z.ZodEnum<{ [k_1 in T[number]]: k_1; } extends infer T_2 ? { [k in keyof T_2]: T_2[k]; } : never>;
+    };
+    /**
+     * JSON field. Three call shapes:
+     *
+     * ```ts
+     * field.json()                                        // unknown JSON blob
+     * field.json(z.array(z.string()))                     // typed JSON with Zod schema
+     * field.json({ icon: z.string().default('default') }) // typed sub-properties with defaults
+     * ```
+     *
+     * The third form is the key DX feature for metadata fields. It wraps the
+     * plain object in `z.object()` automatically, and the model runtime generates
+     * a `${field}Json` getter that parses the JSON string on read, applies Zod
+     * defaults, and caches the result.
+     *
+     * Example:
+     * ```ts
+     * const slideDecks = model({
+     *   metadata: field.json({
+     *     icon: z.string().default('presentation'),
+     *     color: z.string().default('#F59E0B'),
+     *     summary: z.string().optional(),
+     *   }),
+     * });
+     *
+     * // At runtime:
+     * deck.metadata       // raw JSON string (unchanged)
+     * deck.metadataJson   // { icon: 'presentation', color: '#F59E0B', summary: undefined }
+     * deck.metadataJson.icon  // 'presentation' (typed, with default)
+     * ```
+     */
+    readonly json: <T extends z.ZodType = z.ZodUnknown>(schemaOrShape?: T | z.ZodRawShape) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> & {
+        indexed(): z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    };
+    /** Indexed string field (shorthand for `field.string().indexed()`). */
+    readonly id: () => z.ZodString;
+};
+/** Mark a Zod schema as indexed for fast lookups (function form). */
+export declare function indexed<T extends z.ZodType>(schema: T): T;

package/dist/schema/field.js

@@ -0,0 +1,264 @@
+/**
+ * Schema Field Helpers
+ *
+ * Thin wrappers around Zod that add sync-engine metadata (type tag, indexed).
+ * Metadata is stored in `z.describe()` as a JSON-encoded string so it
+ * survives `.optional()`, `.nullable()`, and `.default()` chain calls.
+ *
+ * Usage:
+ *   import { field } from '@ablo/sync-engine/schema';
+ *
+ *   const tasks = model({
+ *     title: field.string(),
+ *     projectId: field.string().indexed(),     // fluent chain
+ *     priority: field.number().optional(),
+ *     status: field.enum(['todo', 'doing', 'done']),
+ *   });
+ *
+ * Or use Zod directly (no metadata, but still works):
+ *   import { z } from 'zod';
+ *
+ *   const tasks = model({
+ *     title: z.string(),
+ *   });
+ */
+import { z } from 'zod';
+// ── Helpers ───────────────────────────────────────────────────────────────
+/** Distinguish a Zod schema from a plain object shape (ZodRawShape). */
+function isZodSchema(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        '_def' in value &&
+        typeof value._def === 'object');
+}
+// ── Metadata encoding ─────────────────────────────────────────────────────
+//
+// We stash metadata in `.describe('__sync:{json}')` so it rides along with
+// the Zod schema through `.optional()`, `.nullable()`, etc. At schema-build
+// time we parse it back out into structured FieldMeta.
+const META_PREFIX = '__sync:';
+function encodeMeta(meta) {
+    return META_PREFIX + JSON.stringify(meta);
+}
+function decodeMeta(description) {
+    if (!description || !description.startsWith(META_PREFIX))
+        return null;
+    try {
+        return JSON.parse(description.slice(META_PREFIX.length));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Extract FieldMeta from a Zod schema. Returns null if no sync-engine
+ * metadata is attached (e.g., raw `z.string()` usage).
+ *
+ * Walks through `.optional()` and `.nullable()` wrappers to find the
+ * underlying description.
+ */
+export function getFieldMeta(schema) {
+    let current = schema;
+    let isOptional = false;
+    // Unwrap optional / nullable / default to reach the inner type
+    // (these are the wrappers that preserve .describe() but may hide it).
+    // `instanceof` keeps the narrowing typed; no `_def` digging.
+    const MAX_UNWRAP = 5;
+    for (let i = 0; i < MAX_UNWRAP; i++) {
+        if (current instanceof z.ZodOptional) {
+            isOptional = true;
+            current = current.unwrap();
+            continue;
+        }
+        if (current instanceof z.ZodNullable) {
+            isOptional = true;
+            current = current.unwrap();
+            continue;
+        }
+        if (current instanceof z.ZodDefault) {
+            // .removeDefault() — v4 deprecates in favor of .unwrap() but
+            // the installed @types only expose removeDefault on ZodDefault.
+            current = current.unwrap();
+            continue;
+        }
+        break;
+    }
+    // The description lives on the innermost schema we reached.
+    const description = current.description ?? schema.description;
+    const base = decodeMeta(description);
+    if (!base)
+        return null;
+    return { ...base, isOptional };
+}
+/**
+ * Fallback: infer FieldMeta directly from a raw Zod schema when no
+ * `field.*()` metadata was attached.
+ *
+ * Walks through `.optional()` / `.nullable()` / `.default()` wrappers
+ * to find the inner primitive, then maps Zod's `_def.typeName` to
+ * the sync-engine type tag. Used by `resolveFieldMeta` and by
+ * `model()` / `query()` at definition time.
+ *
+ * Kept as an internal helper rather than exported directly — the
+ * public API is `resolveFieldMeta`, which combines this fallback
+ * with the `getFieldMeta` fast path.
+ */
+export function inferFieldMetaFromZod(schema) {
+    let current = schema;
+    let isOptional = false;
+    const MAX_UNWRAP = 5;
+    for (let i = 0; i < MAX_UNWRAP; i++) {
+        if (current instanceof z.ZodOptional || current instanceof z.ZodNullable) {
+            isOptional = true;
+            current = current.unwrap();
+            continue;
+        }
+        if (current instanceof z.ZodDefault) {
+            current = current.unwrap();
+            continue;
+        }
+        break;
+    }
+    let type = 'string';
+    let enumValues;
+    if (current instanceof z.ZodString) {
+        type = 'string';
+    }
+    else if (current instanceof z.ZodNumber) {
+        type = 'number';
+    }
+    else if (current instanceof z.ZodBoolean) {
+        type = 'boolean';
+    }
+    else if (current instanceof z.ZodDate) {
+        type = 'date';
+    }
+    else if (current instanceof z.ZodEnum) {
+        type = 'enum';
+        // ZodEnum.options is the public v4 accessor for enum values.
+        enumValues = current.options;
+    }
+    else if (current instanceof z.ZodObject ||
+        current instanceof z.ZodArray ||
+        current instanceof z.ZodRecord ||
+        current instanceof z.ZodUnion ||
+        current instanceof z.ZodUnknown) {
+        type = 'json';
+    }
+    return { type, isOptional, isIndexed: false, enumValues };
+}
+/**
+ * Resolve FieldMeta for any Zod schema — whether it was built with
+ * `field.*()` (which attaches sync-engine metadata) or with raw Zod
+ * (which requires fallback inference from `_def.typeName`).
+ *
+ * This is the single public entry point for "given a Zod field, tell
+ * me its sync-engine type tag and optionality." Both `model()` and
+ * `query()` use it to populate their `fields` / `inputFields` maps at
+ * definition time, and the schema serializer reads those maps at
+ * serialization time.
+ *
+ * Contract: always returns a value. Never returns null. Unknown Zod
+ * types fall through to `'string'` — this is intentional and matches
+ * the existing behavior that was previously duplicated in
+ * `model.ts:inferMetaFromZod`.
+ */
+export function resolveFieldMeta(schema) {
+    const attached = getFieldMeta(schema);
+    if (attached)
+        return attached;
+    return inferFieldMetaFromZod(schema);
+}
+// ── Chainable field builders ──────────────────────────────────────────────
+//
+// Each builder returns the underlying Zod schema (so `z.object(shape)` still
+// works) with `.indexed()` added as a chainable method. `.optional()` and
+// `.nullable()` still come from Zod itself and preserve the description.
+/** Add `.indexed()` to a Zod schema without disturbing its type. */
+function withIndexed(schema, baseMeta) {
+    const described = schema.describe(encodeMeta({ ...baseMeta, isIndexed: false }));
+    described.indexed = () => {
+        return schema.describe(encodeMeta({ ...baseMeta, isIndexed: true }));
+    };
+    return described;
+}
+export const field = {
+    /** String field */
+    string() {
+        return withIndexed(z.string(), { type: 'string' });
+    },
+    /** Number field */
+    number() {
+        return withIndexed(z.number(), { type: 'number' });
+    },
+    /** Boolean field */
+    boolean() {
+        return withIndexed(z.boolean(), { type: 'boolean' });
+    },
+    /** Date field */
+    date() {
+        return withIndexed(z.date(), { type: 'date' });
+    },
+    /** Enum field with constrained string values */
+    enum(values) {
+        return withIndexed(z.enum(values), { type: 'enum', enumValues: values });
+    },
+    /**
+     * JSON field. Three call shapes:
+     *
+     * ```ts
+     * field.json()                                        // unknown JSON blob
+     * field.json(z.array(z.string()))                     // typed JSON with Zod schema
+     * field.json({ icon: z.string().default('default') }) // typed sub-properties with defaults
+     * ```
+     *
+     * The third form is the key DX feature for metadata fields. It wraps the
+     * plain object in `z.object()` automatically, and the model runtime generates
+     * a `${field}Json` getter that parses the JSON string on read, applies Zod
+     * defaults, and caches the result.
+     *
+     * Example:
+     * ```ts
+     * const slideDecks = model({
+     *   metadata: field.json({
+     *     icon: z.string().default('presentation'),
+     *     color: z.string().default('#F59E0B'),
+     *     summary: z.string().optional(),
+     *   }),
+     * });
+     *
+     * // At runtime:
+     * deck.metadata       // raw JSON string (unchanged)
+     * deck.metadataJson   // { icon: 'presentation', color: '#F59E0B', summary: undefined }
+     * deck.metadataJson.icon  // 'presentation' (typed, with default)
+     * ```
+     */
+    json(schemaOrShape) {
+        let inner;
+        if (!schemaOrShape) {
+            inner = z.unknown();
+        }
+        else if (isZodSchema(schemaOrShape)) {
+            inner = schemaOrShape;
+        }
+        else {
+            // Plain object shape → wrap in z.object() for the sub-property pattern
+            inner = z.object(schemaOrShape);
+        }
+        return withIndexed(inner, { type: 'json' });
+    },
+    /** Indexed string field (shorthand for `field.string().indexed()`). */
+    id() {
+        return field.string().indexed();
+    },
+};
+// ── Legacy function form (kept for backward compat) ──────────────────────
+/** Mark a Zod schema as indexed for fast lookups (function form). */
+export function indexed(schema) {
+    // Try to preserve existing metadata type tag if present.
+    const meta = decodeMeta(schema.description);
+    const newMeta = meta
+        ? { ...meta, isIndexed: true }
+        : { type: 'string', isIndexed: true };
+    return schema.describe(encodeMeta(newMeta));
+}

package/dist/schema/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @ablo/sync-engine/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';
+ *
+ * export const schema = defineSchema({
+ *   tasks: model({
+ *     title: z.string(),
+ *     status: z.enum(['todo', 'doing', 'done']).default('todo'),
+ *     projectId: z.string().optional(),
+ *   }, {
+ *     project: relation.belongsTo('projects', 'projectId'),
+ *   }),
+ * });
+ *
+ * type Task = InferModel<typeof schema, 'tasks'>;
+ * ```
+ */
+export { z } from 'zod';
+export { field, indexed, getFieldMeta, type FieldMeta } from './field.js';
+export { relation, type RelationDef, type RelationType } from './relation.js';
+export { model, type ModelDef, type ModelOptions, type LoadStrategy, type PersistOptions, type RelationRecord, } from './model.js';
+export { mutable, readOnly, type SugarOptions } from './sugar.js';
+export { defineSchema, composeIdentitySyncGroups, type Schema, type SchemaRecord, type InferModel, type InferCreate, type InferModelNames, type BaseModelFields, type InsertValue, type UpsertValue, type UpdateValue, type DeleteId, type DefineSchemaOptions, type Casing, type CasingConvention, type CasingFn, type IdentityRole, type IdentityContext, } from './schema.js';
+export { query, defineQueries, type QueryDef, type QueryRecord, type Queries, type InferQueryInput, type InferQueryResult, } from './queries.js';

package/dist/schema/index.js

@@ -0,0 +1,38 @@
+/**
+ * @ablo/sync-engine/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';
+ *
+ * export const schema = defineSchema({
+ *   tasks: model({
+ *     title: z.string(),
+ *     status: z.enum(['todo', 'doing', 'done']).default('todo'),
+ *     projectId: z.string().optional(),
+ *   }, {
+ *     project: relation.belongsTo('projects', 'projectId'),
+ *   }),
+ * });
+ *
+ * type Task = InferModel<typeof schema, 'tasks'>;
+ * ```
+ */
+// Re-export Zod for convenience (consumers can also import directly)
+export { z } from 'zod';
+// Field helpers (optional convenience wrappers around Zod)
+export { field, indexed, getFieldMeta } from './field.js';
+// Relation builders
+export { relation } from './relation.js';
+// Model builder
+export { model, } from './model.js';
+// Intent-first shorthand: `mutable.lazy({...})` and friends. Read the
+// safety posture and load shape off the verb tokens; everything else
+// falls back to sensible defaults. See sugar.ts for the full pattern.
+export { mutable, readOnly } from './sugar.js';
+// Schema definition + type inference
+export { defineSchema, composeIdentitySyncGroups, } from './schema.js';
+// Query definition DSL + type inference
+export { query, defineQueries, } from './queries.js';