@abloatai/ablo 0.36.0 → 0.37.0

package/dist/client/abloClient.d.ts

@@ -1,309 +0,0 @@
-/**
- * The shape of the reactive client — what `Ablo({ schema, apiKey })` hands back.
- *
- * This module owns the declaration; `./Ablo.ts` aliases it as `Ablo<S>` so the
- * factory, the type, and the `Ablo.*` namespace keep merging under one name.
- * The split is what keeps the composition root readable: the contract a caller
- * writes against lives here, the wiring that satisfies it lives there.
- *
- * Type-only, with no runtime imports — the same property that lets `options.ts`
- * and `resourceTypes.ts` be referenced from the HTTP client without importing
- * the factory back and creating a cycle.
- */
-import type { Schema, SchemaRecord, Model, InferCreate, InferRow } from '../transaction/schema/schema.js';
-import type { PresenceStream, Snapshot } from '../transaction/types/streams.js';
-import type { InstanceCache } from '../InstanceCache.js';
-import type { SyncStoreContract } from '../react/context.js';
-import type { SyncWebSocket, CoreSyncEventMap } from '../sync/SyncWebSocket.js';
-import type { SyncStatus } from '../BaseSyncedStore.js';
-import type { ModelOperations } from './createModelProxy.js';
-import type { AbloSession, CommitResource, CreateAgentClientParams, CreateSessionParams } from './resourceTypes.js';
-/** The typed sync engine client — one property per model in the schema */
-export type AbloClient<S extends SchemaRecord> = {
-    readonly [K in keyof S & string]: ModelOperations<Model<Schema<S>, K>, InferCreate<Schema<S>, K>>;
-} & {
-    /**
-     * Wait for the sync engine to finish its initial bootstrap.
-     * Resolves once entity data is loaded and the WebSocket is connected.
-     *
-     * ```ts
-     * const sync = Ablo({ schema, user });
-     * await sync.ready();
-     * const reports = sync.reports.findMany(); // data is available
-     * ```
-     *
-     * If bootstrap fails, this rejects with the underlying error (unreachable
-     * server, invalid API key, 500 from bootstrap endpoint, etc.).
-     *
-     * Idempotent — calling it multiple times returns the same promise.
-     */
-    ready(): Promise<void>;
-    /**
-     * Wait for all pending mutations to be confirmed by the server.
-     *
-     * Sync engine mutations (`create`/`update`/`delete`) are optimistic and
-     * resolve immediately. Use this when you need to know the server has
-     * acknowledged everything before continuing — for example, before
-     * navigating away, before triggering a server-side workflow, or in tests.
-     *
-     * Resolves when `syncStatus.pendingChanges` reaches 0. If the engine is
-     * offline, this waits until reconnect + flush completes.
-     *
-     * ```ts
-     * await sync.reports.create({ data: { title: 'A' } });
-     * await sync.reports.create({ data: { title: 'B' } });
-     * await sync.waitForFlush(); // server has both reports
-     * ```
-     *
-     * @param timeoutMs - Optional timeout. Default: no timeout (wait forever).
-     *                    Throws `Error('Flush timeout')` if reached with pending changes.
-     */
-    waitForFlush(timeoutMs?: number): Promise<void>;
-    /** Disconnect and clean up */
-    dispose(): Promise<void>;
-    /**
-     * Replace the bearer token used for the WebSocket upgrade and HTTP requests,
-     * without tearing down the engine. Use it to push a refreshed short-lived
-     * access key (an `ek_` or `rk_`) before it expires — the client's `apiKey`
-     * resolver refresh loop calls this for you. It reuses the same rotation path as
-     * the internal capability-token refresh and is safe to call before `ready()`.
-     * It also nudges a parked connection to re-probe with the new token.
-     */
-    setAuthToken(token: string): void;
-    /**
-     * Resolve the active bearer credential this engine authenticates with — the
-     * live `ek_` or `rk_` the WebSocket and HTTP transports currently carry (kept
-     * fresh by the `apiKey` resolver refresh loop), falling back to a configured
-     * API key. Returns `null` when no credential is set yet. Use it to authenticate
-     * a side-band request to the same server with the token this client already
-     * holds, avoiding an extra mint round-trip.
-     */
-    getAuthToken(): Promise<string | null>;
-    /**
-     * Register a re-mint hook for the short-lived access key. The connection layer
-     * calls it when it finds the key stale (a `credential_stale` probe) or on an
-     * external nudge; the hook mints a fresh `ek_` or `rk_` from the still-valid
-     * login. It follows the same contract as the `apiKey` resolver: resolve a
-     * token, resolve `null` when the login itself is gone (which signs the user
-     * out), or throw on a transient failure (which backs off without signing out).
-     * The client wires this automatically from a function `apiKey`. Safe to call
-     * before `ready()`.
-     */
-    setCredentialRefresher(refresher: (() => Promise<string | null>) | null): void;
-    /**
-     * Ask the connection layer to re-probe and reconnect now, using the current
-     * credential. Idempotent and safe in any state (a no-op while connected).
-     * Call after an OS-wake signal (Electron `powerMonitor` 'resume') so a
-     * connection parked since sleep recovers immediately instead of waiting for
-     * the watchdog.
-     */
-    nudgeReconnect(): void;
-    /**
-     * Mint a short-lived, scoped session token for one end user. Call this on your
-     * backend, where the `sk_` secret key lives, then hand the returned `token` to
-     * that user's browser — typically through a token route the browser's `apiKey`
-     * resolver fetches. The browser presents the token as its bearer, and the
-     * server verifies it. The browser must never see the `sk_` key, only the
-     * per-user session token.
-     *
-     * Pass `{ user: { id } }` for a full-authority end-user session, which mints an
-     * `ek_` and attributes writes to a user (recorded as `actor_kind` on the delta
-     * row). Pass `{ agent: { id }, can: { tasks: ['update'] } }` for a scoped agent
-     * session, which mints an `rk_`; `can` is typed against your schema's model
-     * names. This always authenticates with the original `sk_`, never the client's
-     * exchanged sync credential.
-     */
-    sessions: {
-        create(params: CreateSessionParams<S>): Promise<AbloSession>;
-    };
-    /**
-     * Mint a scoped **agent identity** and return a ready-to-use client bound to
-     * it — the `ablo.<resource>.<verb>` shape for the agent use case. One call
-     * replaces `sessions.create({ agent })` + constructing a second
-     * `Ablo({ apiKey: token })`:
-     *
-     * ```ts
-     * const agent = await ablo.agents.create({
-     *   name: 'researcher',                  // readable label (optional)
-     *   can: { documents: ['read', 'update'] },
-     *   // id omitted → a fresh uuid: a distinct, independent participant
-     * });
-     * await agent.documents.update({ id, data, claim });
-     * await agent.dispose(); // when the agent is done
-     * ```
-     *
-     * Server-side only: it requires the `sk_` secret key (like `sessions.create`)
-     * and throws `AbloAuthenticationError` in the browser. The returned client
-     * holds its own auto-refreshing `rk_`, so a long run never hits token expiry,
-     * and the `sk_` never leaves this process. Each call is a distinct participant
-     * by default (omit `id` for a fresh uuid), so even two agents sharing a `name`
-     * queue behind one another on a contended row — `name` is display only and
-     * never collapses identity. Humans don't get a server-built client; ship them a
-     * token via `sessions.create({ user })`. If you need the raw token for
-     * revocation, or a stable re-attachable id, use `sessions.create({ agent })`
-     * or pass `id`.
-     */
-    agents: {
-        create(params: CreateAgentClientParams<S>): Promise<AbloClient<S>>;
-    };
-    /**
-     * The organization this client resolved to — `null` until `ready()`
-     * completes. Use it instead of scraping CLI output or hardcoding env vars:
-     *
-     * ```ts
-     * await ablo.ready();
-     * const org = ablo.organizationId; // 'org_…'
-     * ```
-     */
-    readonly organizationId: string | null;
-    /**
-     * Destroy every IndexedDB database owned by this engine. Disconnects
-     * the WebSocket, releases timers, and deletes all `ablo_*` / `ablo-*`
-     * databases. Use on session expiry or explicit logout. Best-effort.
-     */
-    purge(): Promise<void>;
-    /**
-     * Subscribe to session-error events (server rejected the session).
-     * Returns an unsubscribe function. Multiple subscribers supported.
-     * Typically called by `<AbloProvider>`, which calls `purge()` on fire
-     * and forwards to the consumer's `onSessionExpired` callback.
-     */
-    onSessionError(listener: (error: Error) => void): () => void;
-    /**
-     * Subscribe to mutation failures with the full payload (transaction,
-     * error, permanent flag). Use this for user-visible failure surfaces —
-     * toasts keyed by `AbloError.type`, route-level "this entity reverted"
-     * boundaries, telemetry. Fires for both permanent rejections and
-     * `max_retries_exhausted` rollbacks.
-     *
-     * Distinct from `onSessionError` (server killed the session, requires
-     * re-auth) and from the `tx.isPersisted` per-call promise (call-site
-     * await, single transaction). This is the app-wide fan-in.
-     */
-    onMutationFailure(listener: (payload: {
-        transaction: import('../transactions/mutations/MutationQueue.js').QueuedMutation;
-        error: Error;
-        permanent?: boolean;
-    }) => void): () => void;
-    /**
-     * Subscribe to commit round-trip latency — how long each write takes to
-     * land, split into the local durable seal (`sealMs`) and the remote
-     * acknowledgement (`ackMs`). Fires once per completed commit; returns an
-     * unsubscribe function.
-     *
-     * Use this for latency readouts and performance telemetry. It is the only
-     * measurement of the write path: commits travel over the WebSocket, so
-     * `fetch`-based instrumentation never observes them.
-     */
-    onCommitLatency(listener: (sample: import('../transactions/mutations/commitLatency.js').CommitLatencySample) => void): () => void;
-    /**
-     * Wait for the most-recent in-flight transaction for (modelName, modelId)
-     * to be confirmed by the server. Rejects with the same error that the
-     * queue's `transaction:failed` event would carry if the mutation is
-     * permanently rolled back. Resolves immediately when no transaction is
-     * in flight (already-confirmed or never-staged).
-     *
-     * Matches the queue's `'confirmed'` status vocabulary (see also
-     * `commits.create({wait:'confirmed'})`). Use this for the routing-
-     * grace-window pattern: stage a write, then
-     * `Promise.race([ablo.waitForConfirmation(...), gracePromise])` before
-     * navigating to a route whose URL depends on the optimistic id.
-     */
-    waitForConfirmation(modelName: string, modelId: string): Promise<void>;
-    /**
-     * Reactive sync status — a MobX observable.
-     *
-     * Single source of truth for "what's the sync engine doing?" Contains:
-     * - `state`: `'idle' | 'syncing' | 'error' | 'offline' | 'reconnecting'`
-     * - `progress`: 0-100 for bootstrap progress
-     * - `error?`: Error object when `state === 'error'`
-     * - `pendingChanges`: Number of unconfirmed mutations in the queue
-     * - `lastSyncAt?`: Timestamp of the last successful delta processing
-     * - `offlineSince?`: When the connection dropped
-     * - `isSessionError`: True when the error requires re-authentication
-     *
-     * React components using `observer()` re-render automatically when
-     * any field changes — no manual subscription or polling needed.
-     *
-     * ```tsx
-     * import { observer } from 'mobx-react-lite';
-     *
-     * const SyncIndicator = observer(() => {
-     *   if (sync.syncStatus.state === 'syncing') return <Spinner />;
-     *   if (sync.syncStatus.state === 'error') return <Error msg={sync.syncStatus.error} />;
-     *   if (sync.syncStatus.state === 'offline') return <OfflineBadge />;
-     *   return null;
-     * });
-     * ```
-     */
-    readonly syncStatus: SyncStatus;
-    /** The underlying schema */
-    readonly schema: Schema<S>;
-    /**
-     * A real-time presence livestream — who else is connected on this engine's
-     * sync groups, what they're doing, and a write surface for announcing this
-     * user's own activity. It rides the engine's existing WebSocket; opening a
-     * participant for presence does not open a second socket. See
-     * {@link PresenceStream}.
-     *
-     * The reference is stable for the engine's lifetime — the underlying connection
-     * is rotated on `dispose()`, but this object stays the same.
-     */
-    readonly presence: PresenceStream;
-    /**
-     * Canonical low-level mutation API. Every untyped model write compiles
-     * down to `commits.create(...)`.
-     */
-    readonly commits: CommitResource;
-    /**
-     * Capture a context-staleness watermark over a set of entities.
-     * Returns a flat snapshot with `stamp` (thread into writes as
-     * `readAt`), `signal` (aborts on any captured-entity delta), and
-     * `onChange` (callback form). Reads from the engine's InstanceCache;
-     * subscription is on the engine's existing transport.
-     *
-     * Use before an LLM call to prevent the model from completing
-     * against now-stale data:
-     * ```ts
-     * const snap = engine.snapshot({ sections: report.sectionIds });
-     * await streamText({ messages, signal: snap.signal });
-     * ```
-     */
-    snapshot<ModelName extends keyof S & string>(entities: Readonly<Record<ModelName, string | readonly string[]>>): Snapshot<Schema<S>, ModelName>;
-    /**
-     * Subscribe to pushed frames — deltas, presence updates, claim grants and
-     * losses, connection changes. Durable: the subscription survives the
-     * socket being rebuilt across reconnects, and one made before the first
-     * connection starts delivering when it opens. Returns the unsubscribe
-     * function. App-specific collaboration events ride the store's own typed
-     * map — see `_store`.
-     */
-    subscribe<K extends keyof CoreSyncEventMap>(event: K, handler: (...args: CoreSyncEventMap[K]) => void): () => void;
-    /**
-     * The internal store. It implements {@link SyncStoreContract} — pass it to
-     * `SyncContext.Provider` so the SDK's `useModel` / `useModels` / `useMutations`
-     * hooks can reach it.
-     */
-    readonly _store: SyncStoreContract;
-    /** The InstanceCache — for demand loaders and direct pool operations. */
-    readonly _pool: InstanceCache;
-    /**
-     * The SyncWebSocket handle — for collaboration events (selection, cursor
-     * broadcast). Present for the client's whole lifetime: the connection object
-     * is built with the store and holds no socket until `connect()`, so there is
-     * no window in which this is absent and nothing needs to guard for one.
-     */
-    readonly _ws: SyncWebSocket;
-};
-/**
- * The reactive-read client a `useAblo` selector receives. The same surface as
- * {@link AbloClient}, except model reads are typed as reactive rows
- * ({@link InferRow}: data fields + computeds, no relation accessors, no model
- * methods) — the shape a reactive read actually delivers after
- * `toReactiveSnapshot()`. Reading `row.blocks` off a reactive read is a
- * compile error here instead of a silent runtime `undefined`; compose
- * relations through selectors or hooks that resolve the pool's instance.
- */
-export type AbloReads<S extends SchemaRecord> = Omit<AbloClient<S>, keyof S & string> & {
-    readonly [K in keyof S & string]: ModelOperations<InferRow<Schema<S>, K>, InferCreate<Schema<S>, K>>;
-};

package/dist/client/abloClient.js

@@ -1,13 +0,0 @@
-/**
- * The shape of the reactive client — what `Ablo({ schema, apiKey })` hands back.
- *
- * This module owns the declaration; `./Ablo.ts` aliases it as `Ablo<S>` so the
- * factory, the type, and the `Ablo.*` namespace keep merging under one name.
- * The split is what keeps the composition root readable: the contract a caller
- * writes against lives here, the wiring that satisfies it lives there.
- *
- * Type-only, with no runtime imports — the same property that lets `options.ts`
- * and `resourceTypes.ts` be referenced from the HTTP client without importing
- * the factory back and creating a cycle.
- */
-export {};

package/dist/client/clientPrelude.d.ts

@@ -1,52 +0,0 @@
-/**
- * The prelude every socket client resolves before anything is constructed.
- *
- * One pass over the options bag settles the values the composition root then
- * spends: the credential and its refresh resolver, the base URL, the logger,
- * and this participant's identity. Nothing here opens a socket, allocates a
- * store, or touches IndexedDB — so a misconfiguration (a secret key in the
- * browser, the removed `databaseUrl` option, a CLI key pointing at another
- * project) fails while the stack still points at the caller's own setup.
- *
- * `./Ablo.ts` calls this once and hands the result to whichever client the
- * plugin list selected.
- */
-import type { ParticipantKind } from '../transaction/types/participant.js';
-import type { Logger } from '../transaction/logger.js';
-import type { SchemaRecord } from '../transaction/schema/schema.js';
-import { type AuthCredentialSource } from '../transaction/auth/credentialSource.js';
-import { type ApiKeySetter } from '../transaction/auth/apiKey.js';
-import type { AbloOptions, InternalAbloOptions } from './options.js';
-/** What one pass over the options bag settles, for the builders downstream. */
-export interface ClientPrelude<S extends SchemaRecord> {
-    /** The same options, widened to the fields only the SDK's own callers set. */
-    readonly internalOptions: InternalAbloOptions<S>;
-    /** The configured key — a literal key string, or a resolver to call. */
-    readonly configuredApiKey: string | ApiKeySetter | null;
-    readonly configuredAuthToken: string | null;
-    /**
-     * The credential lifecycle's single resolver, or `null` when auth is static.
-     * It drives both the reactive re-mint (the connection's `credential_stale`
-     * state) and the proactive refresh timer with its wake/online/focus triggers.
-     */
-    readonly credentialResolver: (() => Promise<string | null>) | null;
-    readonly authCredentials: AuthCredentialSource;
-    readonly logger: Logger;
-    readonly url: string;
-    /**
-     * Identity routing: agents identify by agentId, users by user.id. The server
-     * stamps `isAgent` on outbound presence frames from the connection's
-     * authenticated identity prefix; the local `self` entry uses the kind we know
-     * at construction.
-     */
-    readonly participantId: string;
-    readonly kind: ParticipantKind;
-}
-/**
- * Resolve the prelude, failing fast on a misconfiguration.
- *
- * Three checks fire here rather than downstream: a secret key reaching the
- * browser, the removed `databaseUrl` option, and a CLI key scoped to a
- * different project than the one being addressed (a warning, not a throw).
- */
-export declare function resolveClientPrelude<S extends SchemaRecord>(options: AbloOptions<S>): ClientPrelude<S>;

package/dist/client/clientPrelude.js

@@ -1,60 +0,0 @@
-/**
- * The prelude every socket client resolves before anything is constructed.
- *
- * One pass over the options bag settles the values the composition root then
- * spends: the credential and its refresh resolver, the base URL, the logger,
- * and this participant's identity. Nothing here opens a socket, allocates a
- * store, or touches IndexedDB — so a misconfiguration (a secret key in the
- * browser, the removed `databaseUrl` option, a CLI key pointing at another
- * project) fails while the stack still points at the caller's own setup.
- *
- * `./Ablo.ts` calls this once and hands the result to whichever client the
- * plugin list selected.
- */
-import { createAuthCredentialSource, } from '../transaction/auth/credentialSource.js';
-import { assertBrowserSafety, readProcessEnv, rejectRemovedDatabaseUrlOption, resolveApiKey, resolveAuthToken, resolveBaseURL, resolveCredentialResolver, warnIfCliKeyMismatch, } from '../transaction/auth/apiKey.js';
-import { createConsoleLogger, resolveLogLevel } from './consoleLogger.js';
-/**
- * Resolve the prelude, failing fast on a misconfiguration.
- *
- * Three checks fire here rather than downstream: a secret key reaching the
- * browser, the removed `databaseUrl` option, and a CLI key scoped to a
- * different project than the one being addressed (a warning, not a throw).
- */
-export function resolveClientPrelude(options) {
-    const internalOptions = options;
-    const env = readProcessEnv();
-    const authInput = { options, env };
-    const configuredApiKey = resolveApiKey(authInput);
-    const configuredAuthToken = resolveAuthToken(authInput);
-    const credentialResolver = resolveCredentialResolver(configuredApiKey);
-    const authCredentials = createAuthCredentialSource(
-    // eslint-disable-next-line @typescript-eslint/no-deprecated -- load-bearing on the self-hosted path; server-internal cap-mint (Phase 3) not shipped
-    internalOptions.capabilityToken ?? configuredAuthToken);
-    rejectRemovedDatabaseUrlOption(options);
-    assertBrowserSafety({
-        apiKey: configuredApiKey,
-        dangerouslyAllowBrowser: options.dangerouslyAllowBrowser,
-    });
-    // Custom logger wins; otherwise build the default `[Ablo]` logger at the level
-    // resolved from `debug`/`logLevel`/`ABLO_LOG_LEVEL` (default `warn`).
-    const logger = internalOptions.logger ??
-        createConsoleLogger(resolveLogLevel({ debug: options.debug, logLevel: options.logLevel }));
-    void warnIfCliKeyMismatch(authInput, (m) => { logger.warn(m); });
-    const participantId = 
-    // eslint-disable-next-line @typescript-eslint/no-deprecated -- self-hosted identity fallback; hosted path derives identity from the apiKey scope
-    (internalOptions.kind === 'agent' ? internalOptions.agentId : internalOptions.user?.id) ?? '';
-    // eslint-disable-next-line @typescript-eslint/no-deprecated -- self-hosted default; hosted path ignores it (server derives kind from the apiKey scope)
-    const kind = internalOptions.kind ?? 'user';
-    return {
-        internalOptions,
-        configuredApiKey,
-        configuredAuthToken,
-        credentialResolver,
-        authCredentials,
-        logger,
-        url: resolveBaseURL(authInput),
-        participantId,
-        kind,
-    };
-}

package/dist/client/consoleLogger.d.ts

@@ -1,35 +0,0 @@
-/**
- * The default `[Ablo]` console logger and its level resolution.
- *
- * These helpers are exported so any entry point that needs a default logger can
- * reuse the same level gating rather than hand-rolling a console wrapper.
- */
-import type { Logger } from '../interfaces/index.js';
-/**
- * Level threshold for the default console logger.
- *
- * The SDK emits a `debug` line per model and per property during schema
- * registration (see `ModelRegistry`), plus assorted lifecycle chatter. That
- * is verbose by design but carries no actionable signal for app consumers, so
- * the default threshold is `warn` — `debug`/`info` are dropped unless a
- * consumer opts in.
- *
- * Opt back in with `ABLO_LOG_LEVEL=debug` (or `info`/`warn`/`error`/`silent`).
- * Passing a custom `logger` to `Ablo({ logger })` bypasses this entirely.
- */
-export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent';
-/**
- * Resolve the effective level. Precedence: explicit `logLevel` option →
- * `debug: true` (⇒ debug) → `ABLO_LOG_LEVEL` env → default `warn`. `debug: false`
- * / omitted just means "don't raise the level" — it falls through to env/default
- * rather than force-silencing an ops-set env override.
- */
-export declare function resolveLogLevel(opts?: {
-    debug?: boolean;
-    logLevel?: LogLevel;
-}): LogLevel;
-/**
- * Builds the default logger, gated at `level` and prefixed `[Ablo]` so its lines
- * stand out in a console full of other tools' output.
- */
-export declare function createConsoleLogger(level: LogLevel): Logger;

package/dist/client/consoleLogger.js

@@ -1,44 +0,0 @@
-/**
- * The default `[Ablo]` console logger and its level resolution.
- *
- * These helpers are exported so any entry point that needs a default logger can
- * reuse the same level gating rather than hand-rolling a console wrapper.
- */
-const LOG_LEVEL_RANK = { debug: 10, info: 20, warn: 30, error: 40, silent: 99 };
-/**
- * Resolve the effective level. Precedence: explicit `logLevel` option →
- * `debug: true` (⇒ debug) → `ABLO_LOG_LEVEL` env → default `warn`. `debug: false`
- * / omitted just means "don't raise the level" — it falls through to env/default
- * rather than force-silencing an ops-set env override.
- */
-export function resolveLogLevel(opts) {
-    if (opts?.logLevel && opts.logLevel in LOG_LEVEL_RANK)
-        return opts.logLevel;
-    if (opts?.debug === true)
-        return 'debug';
-    // `globalThis.process` guard keeps this safe in browser/edge runtimes that
-    // have no `process` binding — there we fall through to the default.
-    const raw = globalThis.process?.env?.ABLO_LOG_LEVEL;
-    const normalized = raw?.toLowerCase();
-    if (normalized && normalized in LOG_LEVEL_RANK)
-        return normalized;
-    return 'warn';
-}
-/**
- * Builds the default logger, gated at `level` and prefixed `[Ablo]` so its lines
- * stand out in a console full of other tools' output.
- */
-export function createConsoleLogger(level) {
-    const threshold = LOG_LEVEL_RANK[level];
-    const emit = (lvl, fn, args) => {
-        if (typeof console === 'undefined' || LOG_LEVEL_RANK[lvl] < threshold)
-            return;
-        fn('[Ablo]', ...args);
-    };
-    return {
-        debug: (...args) => { emit('debug', console.debug, args); },
-        info: (...args) => { emit('info', console.info, args); },
-        warn: (...args) => { emit('warn', console.warn, args); },
-        error: (...args) => { emit('error', console.error, args); },
-    };
-}

package/dist/client/coreClient.d.ts

@@ -1,60 +0,0 @@
-/**
- * The core client over the socket: the stateless surface plus the live feed
- * (ADR 0016). `Ablo({ ..., plugins: [] })` returns this — the empty list says
- * it plainly: nothing beyond the core. Reads and writes travel over
- * request-response, exactly as they do for the `transport: 'http'` client;
- * the socket adds push — deltas, presence frames, and the claim lifecycle
- * (granted, queued, lost) — without a local copy of anything.
- *
- * This is the membership test made constructible: a caller with no socket
- * loses only push, and polls instead; a caller with this client gets the
- * push back and still never holds a store it did not ask for. It also
- * satisfies the core coordination ports structurally — `awaitClaimGrant`
- * needs only `subscribe`, which this client has.
- */
-import type { SchemaRecord } from '../transaction/schema/schema.js';
-import { type AbloHttpClient } from '../transaction/transport/httpClient.js';
-import { WsTransport } from '../transaction/transport/wsTransport.js';
-import type { ClaimStream } from '../transaction/types/streams.js';
-import type { Logger } from '../transaction/logger.js';
-import type { ObservabilityProvider } from '../interfaces/index.js';
-import type { AbloOptions } from './options.js';
-import type { ParticipantKind } from '../transaction/types/participant.js';
-/**
- * The stateless surface plus the live feed. Everything `transport: 'http'`
- * offers — typed model reads and writes, commits, claims, session minting —
- * with a duplex connection alongside it for the frames the server initiates.
- */
-export type AbloCoreClient<S extends SchemaRecord> = AbloHttpClient<S> & {
-    /**
-     * Opens the live feed and resolves once the connection is up. Reads and
-     * writes work before, during, and after — they never depend on the feed.
-     */
-    connect(options?: {
-        timeoutMs?: number;
-    }): Promise<void>;
-    /** Closes the live feed. Reads and writes keep working over request-response. */
-    disconnect(): void;
-    /** True while the live feed is up. */
-    isConnected(): boolean;
-    /**
-     * Subscribe to pushed frames — deltas, presence updates, claim grants and
-     * losses. Returns the unsubscribe function.
-     */
-    subscribe: WsTransport['subscribe'];
-    /** Other participants' open claims and the wait queues, kept live off the feed. */
-    claims: ClaimStream;
-};
-export interface CoreClientArgs<S extends SchemaRecord> {
-    options: AbloOptions<S>;
-    /** The resolved sync-server base URL. */
-    baseUrl: string;
-    participantId: string;
-    kind: ParticipantKind;
-    syncGroups: readonly string[];
-    /** The shared credential source's resolver — reconnects read the freshest token. */
-    getAuthToken: () => string | null | undefined;
-    logger: Logger;
-    observability?: ObservabilityProvider;
-}
-export declare function createCoreClient<S extends SchemaRecord>(args: CoreClientArgs<S>): AbloCoreClient<S>;