@abloatai/ablo 0.35.0 → 0.37.0

package/dist/transaction/logPosition.d.ts

@@ -1,97 +0,0 @@
-/**
- * Records where this client stands in the global delta order. It is a single
- * typed object holding three related but distinct positions, each with its own
- * rule for when it may advance. Keeping them separate is deliberate: collapsing
- * them into one counter is a classic source of sync bugs.
- *
- *   - `persisted` — the resume cursor. It advances only after deltas have
- *     committed to durable local storage. This is the value reconnect catch-up
- *     sends to the server, so it must never run ahead of what actually landed
- *     on disk; otherwise the server would skip deltas the client never stored.
- *
- *   - `applied` — the in-memory cursor: the last delta applied to the object
- *     pool. It drives the guards that deduplicate and reject replayed deltas.
- *     It may run ahead of `persisted`, because the pool is updated before the
- *     flush to disk, and behind what has merely been received, because
- *     bootstrap-queued deltas arrive before they are applied.
- *
- *   - `acked` — the highest server position acknowledged for this client's own
- *     commits. An acknowledgement at N means the server applied our write at N;
- *     the optimistic pool already reflects it, so for the entities we wrote we
- *     have effectively read through N even before the echo returns on the
- *     stream.
- *
- * One value is derived: `readFloor` is the greater of `applied` and `acked`,
- * and is the only position a snapshot or claim should stamp as its read point.
- * Using the raw stream cursor alone would make a claim taken right after a
- * confirmed write look stale against that write's own delta; using the raw
- * acknowledgement alone would be wrong for read-only clients. The maximum is
- * correct per entity, because a competing change to an entity we just wrote
- * necessarily lands above our acknowledgement and still rejects as stale.
- *
- * The validation schema is the state shape: the class holds exactly one
- * {@link LogPositionSnapshot} and merges monotonically into it, so snapshot
- * and restore share that shape and {@link parseLogPosition} is the single gate
- * for anything loaded from disk — a corrupted cursor stored "ahead of reality"
- * being a known failure mode.
- */
-import { z } from 'zod';
-export declare const logPositionSchema: z.ZodObject<{
-    persisted: z.ZodNumber;
-    applied: z.ZodNumber;
-    acked: z.ZodNumber;
-}, z.core.$strip>;
-export type LogPositionSnapshot = z.infer<typeof logPositionSchema>;
-/**
- * Only the `persisted` cursor is stored durably; `applied` and `acked` are
- * not. On resume the object pool is rebuilt from the persisted state, so the
- * correct restore is simply to advance `persisted` to the stored value, which
- * also implies `applied`. `acked` starts at zero, because a past session's
- * acknowledgements carry no read authority and the offline queue
- * re-acknowledges its own replays.
- */
-/**
- * Validates an untrusted value, such as one loaded from disk, into a position
- * snapshot, or returns null when it does not match the schema.
- */
-export declare function parseLogPosition(value: unknown): LogPositionSnapshot | null;
-/**
- * The live sync position: one instance per client. Three producers each
- * advance their own cursor, and consumers read the result.
- */
-export declare class LogPosition {
-    #private;
-    /** Returns a copy of the current state in the schema's shape. */
-    snapshot(): LogPositionSnapshot;
-    get persisted(): number;
-    get applied(): number;
-    get acked(): number;
-    /** The position a snapshot or claim stamps as its read point: the greater of `applied` and `acked`. */
-    get readFloor(): number;
-    /**
-     * Records that deltas through `syncId` have committed to durable local
-     * storage. This also advances `applied`, since the flush applies each delta
-     * before or as it persists.
-     */
-    advancePersisted(syncId: number): void;
-    /** Records that a delta was applied to the in-memory object pool. */
-    advanceApplied(syncId: number): void;
-    /** Records that the server acknowledged one of this client's commits at the given position. */
-    noteAck(lastSyncId: number | undefined): void;
-    /** Restores from an already-validated snapshot, for example on resume from disk. The merge is monotonic. */
-    restore(snapshot: LogPositionSnapshot): void;
-}
-/** @deprecated Renamed to {@link logPositionSchema}. Removed in 0.36.0. */
-export declare const syncPositionSchema: z.ZodObject<{
-    persisted: z.ZodNumber;
-    applied: z.ZodNumber;
-    acked: z.ZodNumber;
-}, z.core.$strip>;
-/** @deprecated Renamed to {@link LogPositionSnapshot}. Removed in 0.36.0. */
-export type SyncPositionSnapshot = LogPositionSnapshot;
-/** @deprecated Renamed to {@link parseLogPosition}. Removed in 0.36.0. */
-export declare const parseSyncPosition: typeof parseLogPosition;
-/** @deprecated Renamed to {@link LogPosition}. Removed in 0.36.0. */
-export declare const SyncPosition: typeof LogPosition;
-/** @deprecated Renamed to {@link LogPosition}. Removed in 0.36.0. */
-export type SyncPosition = LogPosition;

package/dist/transaction/logPosition.js

@@ -1,125 +0,0 @@
-/**
- * Records where this client stands in the global delta order. It is a single
- * typed object holding three related but distinct positions, each with its own
- * rule for when it may advance. Keeping them separate is deliberate: collapsing
- * them into one counter is a classic source of sync bugs.
- *
- *   - `persisted` — the resume cursor. It advances only after deltas have
- *     committed to durable local storage. This is the value reconnect catch-up
- *     sends to the server, so it must never run ahead of what actually landed
- *     on disk; otherwise the server would skip deltas the client never stored.
- *
- *   - `applied` — the in-memory cursor: the last delta applied to the object
- *     pool. It drives the guards that deduplicate and reject replayed deltas.
- *     It may run ahead of `persisted`, because the pool is updated before the
- *     flush to disk, and behind what has merely been received, because
- *     bootstrap-queued deltas arrive before they are applied.
- *
- *   - `acked` — the highest server position acknowledged for this client's own
- *     commits. An acknowledgement at N means the server applied our write at N;
- *     the optimistic pool already reflects it, so for the entities we wrote we
- *     have effectively read through N even before the echo returns on the
- *     stream.
- *
- * One value is derived: `readFloor` is the greater of `applied` and `acked`,
- * and is the only position a snapshot or claim should stamp as its read point.
- * Using the raw stream cursor alone would make a claim taken right after a
- * confirmed write look stale against that write's own delta; using the raw
- * acknowledgement alone would be wrong for read-only clients. The maximum is
- * correct per entity, because a competing change to an entity we just wrote
- * necessarily lands above our acknowledgement and still rejects as stale.
- *
- * The validation schema is the state shape: the class holds exactly one
- * {@link LogPositionSnapshot} and merges monotonically into it, so snapshot
- * and restore share that shape and {@link parseLogPosition} is the single gate
- * for anything loaded from disk — a corrupted cursor stored "ahead of reality"
- * being a known failure mode.
- */
-import { z } from 'zod';
-export const logPositionSchema = z.object({
-    /** The resume cursor; advances only after deltas persist to durable local storage. */
-    persisted: z.number().int().nonnegative(),
-    /** The in-memory cursor: the last delta applied to the object pool. */
-    applied: z.number().int().nonnegative(),
-    /** The highest server position acknowledged for this client's own commits. */
-    acked: z.number().int().nonnegative(),
-});
-/**
- * Only the `persisted` cursor is stored durably; `applied` and `acked` are
- * not. On resume the object pool is rebuilt from the persisted state, so the
- * correct restore is simply to advance `persisted` to the stored value, which
- * also implies `applied`. `acked` starts at zero, because a past session's
- * acknowledgements carry no read authority and the offline queue
- * re-acknowledges its own replays.
- */
-/**
- * Validates an untrusted value, such as one loaded from disk, into a position
- * snapshot, or returns null when it does not match the schema.
- */
-export function parseLogPosition(value) {
-    const result = logPositionSchema.safeParse(value);
-    return result.success ? result.data : null;
-}
-const ZERO = { persisted: 0, applied: 0, acked: 0 };
-/** Monotonic merge: each cursor only ever moves forward. */
-function advance(state, next) {
-    return {
-        persisted: Math.max(state.persisted, next.persisted ?? 0),
-        applied: Math.max(state.applied, next.applied ?? 0),
-        acked: Math.max(state.acked, next.acked ?? 0),
-    };
-}
-/**
- * The live sync position: one instance per client. Three producers each
- * advance their own cursor, and consumers read the result.
- */
-export class LogPosition {
-    #state = ZERO;
-    /** Returns a copy of the current state in the schema's shape. */
-    snapshot() {
-        return { ...this.#state };
-    }
-    get persisted() {
-        return this.#state.persisted;
-    }
-    get applied() {
-        return this.#state.applied;
-    }
-    get acked() {
-        return this.#state.acked;
-    }
-    /** The position a snapshot or claim stamps as its read point: the greater of `applied` and `acked`. */
-    get readFloor() {
-        return Math.max(this.#state.applied, this.#state.acked);
-    }
-    /**
-     * Records that deltas through `syncId` have committed to durable local
-     * storage. This also advances `applied`, since the flush applies each delta
-     * before or as it persists.
-     */
-    advancePersisted(syncId) {
-        this.#state = advance(this.#state, { persisted: syncId, applied: syncId });
-    }
-    /** Records that a delta was applied to the in-memory object pool. */
-    advanceApplied(syncId) {
-        this.#state = advance(this.#state, { applied: syncId });
-    }
-    /** Records that the server acknowledged one of this client's commits at the given position. */
-    noteAck(lastSyncId) {
-        if (lastSyncId !== undefined)
-            this.#state = advance(this.#state, { acked: lastSyncId });
-    }
-    /** Restores from an already-validated snapshot, for example on resume from disk. The merge is monotonic. */
-    restore(snapshot) {
-        this.#state = advance(this.#state, snapshot);
-    }
-}
-// ── Deprecated aliases (renamed from the sync/syncPosition module, 2026-07-17) ──
-// The position is a participant's place in the transaction log; the old names
-// said the consumer. Same class, same instanceof identity. Removed in 0.36.0.
-/** @deprecated Renamed to {@link logPositionSchema}. Removed in 0.36.0. */
-export const syncPositionSchema = logPositionSchema;
-/** @deprecated Renamed to {@link parseLogPosition}. Removed in 0.36.0. */
-export const parseSyncPosition = parseLogPosition;
-/** @deprecated Renamed to {@link LogPosition}. Removed in 0.36.0. */
-export const SyncPosition = LogPosition;

package/dist/transaction/logger.d.ts

@@ -1,16 +0,0 @@
-/**
- * The logging port the SDK writes through.
- *
- * A contract with no framework and no local state: credential exchange, commit,
- * and claim all need to log with no UI and no offline store present, so the port
- * belongs to the settlement core (ADR 0016). The consumer supplies the
- * implementation; the SDK ships a no-op default.
- */
-export interface Logger {
-    debug(message: string, ...args: unknown[]): void;
-    info(message: string, ...args: unknown[]): void;
-    warn(message: string, ...args: unknown[]): void;
-    error(message: string, ...args: unknown[]): void;
-}
-/** The no-op default — what the core logs through when no logger is wired. */
-export declare const noopLogger: Logger;

package/dist/transaction/logger.js

@@ -1,7 +0,0 @@
-/** The no-op default — what the core logs through when no logger is wired. */
-export const noopLogger = {
-    debug() { },
-    info() { },
-    warn() { },
-    error() { },
-};

package/dist/transaction/observability.d.ts

@@ -1,53 +0,0 @@
-/**
- * The observability the settlement core reports on its own behalf.
- *
- * Coordination outcomes — a claim changing state, a stale-write collision that
- * notified instead of aborting — happen with no UI and no local store anywhere,
- * so the core must be able to report them without depending on the consumer's
- * full provider (ADR 0016).
- *
- * This is deliberately the narrow set the core actually calls today. Widening it
- * later is non-breaking; the reactive engine's `ObservabilityProvider` extends
- * this interface, so a single implementation still satisfies both.
- */
-import type { ClaimEvent, ConflictEvent } from './coordination/events.js';
-export interface CoordinationObservability {
-    /** Capture a claim state change (acquired / queued / granted / lost / rejected / expired). */
-    captureClaim(event: ClaimEvent): void;
-    /** Capture a notify-instead-of-abort stale-write collision. */
-    captureConflict(event: ConflictEvent): void;
-}
-/** Breadcrumb severity levels */
-export type BreadcrumbLevel = 'debug' | 'info' | 'warning' | 'error';
-/** Breadcrumb categories for sync engine lifecycle events */
-export type BreadcrumbCategory = 'sync.bootstrap' | 'sync.transaction' | 'sync.websocket' | 'sync.offline' | 'sync.database' | 'sync.conflict' | 'sync.coordination' | 'sync.groups';
-export interface WebSocketErrorDetails {
-    context: string;
-    error?: string;
-    code?: number;
-    reason?: string;
-}
-/**
- * The observability the duplex transport reports on its own behalf: connection
- * lifecycle breadcrumbs and socket errors. A server-side agent holding a socket
- * for claim push has no store and no UI, so the transport must be able to
- * report without the consumer's full provider — the same reasoning as
- * {@link CoordinationObservability}, one layer down. The reactive engine's
- * `ObservabilityProvider` extends this interface, so a single implementation
- * satisfies both.
- */
-export interface TransportObservability {
-    /** Add a breadcrumb for sync lifecycle events */
-    breadcrumb(message: string, category: BreadcrumbCategory, level?: BreadcrumbLevel, data?: Record<string, string | number | boolean | undefined>): void;
-    /** Capture WebSocket error */
-    captureWebSocketError(details: WebSocketErrorDetails): void;
-}
-/**
- * Everything the duplex transport reports: its own lifecycle
- * ({@link TransportObservability}) plus the coordination outcomes that ride
- * the socket ({@link CoordinationObservability} — claim pushes and notified
- * collisions arrive as frames, so the transport is where they surface).
- */
-export type SocketObservability = TransportObservability & CoordinationObservability;
-/** The no-op default — what the transport reports through when nothing is wired. */
-export declare const noopSocketObservability: SocketObservability;

package/dist/transaction/observability.js

@@ -1,19 +0,0 @@
-/**
- * The observability the settlement core reports on its own behalf.
- *
- * Coordination outcomes — a claim changing state, a stale-write collision that
- * notified instead of aborting — happen with no UI and no local store anywhere,
- * so the core must be able to report them without depending on the consumer's
- * full provider (ADR 0016).
- *
- * This is deliberately the narrow set the core actually calls today. Widening it
- * later is non-breaking; the reactive engine's `ObservabilityProvider` extends
- * this interface, so a single implementation still satisfies both.
- */
-/** The no-op default — what the transport reports through when nothing is wired. */
-export const noopSocketObservability = {
-    breadcrumb() { },
-    captureWebSocketError() { },
-    captureClaim() { },
-    captureConflict() { },
-};

package/dist/transaction/persistence.d.ts

@@ -1,12 +0,0 @@
-/**
- * Local persistence modes. `'memory'` (the default everywhere outside the
- * browser) keeps the local graph in process memory; `'indexeddb'` adds
- * offline queueing and a reload-surviving cache in the browser.
- */
-export type AbloPersistence = 'memory' | 'indexeddb';
-export interface PersistenceOptions {
-    readonly persistence?: AbloPersistence | undefined;
-    readonly inMemory?: boolean | undefined;
-    readonly offline?: boolean | undefined;
-}
-export declare function shouldUseInMemoryPersistence(options: PersistenceOptions): boolean;

package/dist/transaction/persistence.js

@@ -1,11 +0,0 @@
-export function shouldUseInMemoryPersistence(options) {
-    if (typeof window === 'undefined')
-        return true;
-    if (options.persistence)
-        return options.persistence === 'memory';
-    if (typeof options.inMemory === 'boolean')
-        return options.inMemory;
-    if (options.offline === true)
-        return false;
-    return true;
-}

package/dist/transaction/plugin.d.ts

@@ -1,192 +0,0 @@
-/**
- * The plugin contract (ADR 0016).
- *
- * The core is `commit` · `get`/`list` · `observe` · `claim` · auth. Everything
- * else a caller might want — a local materialised copy, presence rendering,
- * batching, framework bindings — is a plugin declared in one list, so a server
- * or an agent installs only what it asked for.
- *
- * Every plugin has the same shape on purpose. Uniformity is what makes the list
- * composable and the types inferable; bespoke plugins would reproduce today's
- * nineteen export subpaths with extra ceremony.
- *
- * Where this shape came from, and the field-by-field reasoning behind it, is
- * recorded in ADR 0016 — the contract itself only states what each field does.
- */
-import type { ParticipantKind } from './types/participant.js';
-import type { ErrorCodeSpec } from './errorCodes.js';
-import type { Logger } from './logger.js';
-import type { CoordinationObservability } from './observability.js';
-import type { WsTransport } from './transport/wsTransport.js';
-/**
- * A string type that keeps literal inference alive: `id: 'humans'` stays the
- * literal `'humans'` through object-literal inference instead of widening to
- * `string`, which is what lets {@link InstalledSurface} key a plugin list's
- * surface by id.
- */
-export type LiteralString = '' | (string & Record<never, never>);
-/**
- * The ordered stages a delta passes through on its way from the feed into
- * whatever is watching. A plugin names the one it attaches to.
- *
- * The order is not a convention — it is a correctness constraint. `acknowledge`
- * must follow `persist`, because acknowledging the input range rather than the
- * persisted high-water mark advances the server's cursor past deltas that never
- * committed, and the next catch-up then answers "you're up to date" for a delta
- * that was lost. Declaring the stage keeps that ordering out of array position,
- * where it would be load-bearing and undocumented.
- */
-export type PipelineStage = 
-/** Deltas arrive from `observe()` and are queued. */
-'receive'
-/** Per-entity collapse of the queued batch. */
- | 'dedupe'
-/** The batch is written to durable local storage. */
- | 'persist'
-/** Persisted results land in the in-memory graph. */
- | 'apply'
-/** The cursor advances — gated on `persist`, never on the input range. */
- | 'acknowledge'
-/** Anything downstream reacts: re-render, presence, subscribers. */
- | 'notify';
-/** Canonical order. A plugin runner must run stages in this sequence. */
-export declare const PIPELINE_STAGES: readonly PipelineStage[];
-/**
- * What a capability needs from whatever transport was selected.
- *
- * Transport is a slot the caller fills, not a packaging axis, so a capability
- * states its requirement and an incompatible pairing fails when the client is
- * configured — with a typed error naming the plugin — rather than at runtime
- * with a subscription that silently never delivers.
- */
-export interface TransportCapabilities {
-    /**
-     * Requires a transport the server can initiate frames on. Live subscriptions,
-     * presence, and claim grants need this; commit and point-in-time reads do not.
-     */
-    readonly duplex?: boolean;
-}
-/**
- * The core surface a plugin is handed at construction.
- *
- * Generic over the client's options type: the host instantiates it with its
- * own options bag, so a plugin reads configuration without this package
- * naming any consumer's types. Alongside the raw options, the context
- * carries the values the host has already resolved (`participant`,
- * `syncGroups`), so a plugin never re-derives identity.
- */
-export interface PluginContext<Options = unknown> {
-    readonly logger: Logger;
-    readonly observability?: CoordinationObservability;
-    /** The client's own options bag, as the host received it. */
-    readonly options?: Options;
-    /**
-     * The live duplex connection. The host builds it during construction, so a
-     * plugin holds the thing rather than a function that fetches it: the
-     * connection object is stable for the client's lifetime — identity and
-     * read scope are seeded into it when they resolve, and reconnects replace
-     * only the socket inside it, never the object. Absent on a
-     * request-response client, which is what `requires: { duplex: true }`
-     * guards.
-     */
-    readonly transport?: WsTransport;
-    /** The participant this client runs as, when known at construction. */
-    readonly participant?: {
-        readonly id: string;
-        readonly kind: ParticipantKind;
-    };
-    /** The connection's initial read scope (sync groups). */
-    readonly syncGroups?: readonly string[];
-}
-/**
- * One installed capability.
- *
- * @typeParam Surface - what `init` contributes to the client. The plugin list's
- * element types are what let the installed surface be inferred rather than
- * declared.
- */
-export interface AbloPlugin<Surface = unknown> {
-    /** Stable identity — deduplication, diagnostics, and error attribution.
-     *  Literal-typed so a list's installed surface can be keyed by it. */
-    readonly id: LiteralString;
-    /** The plugin's own version, for diagnostics. */
-    readonly version?: string;
-    /** What this plugin needs from the transport. Checked at configuration time. */
-    readonly requires?: TransportCapabilities;
-    /**
-     * Whether this plugin keeps a local copy of rows.
-     *
-     * This is ADR 0013 §4's membership test as a declared, checkable property
-     * rather than a rule someone has to remember: a stateless caller can assert
-     * that nothing in its list materialises, and CI can assert the core's own
-     * list is uniformly `false`.
-     */
-    readonly materialises: boolean;
-    /**
-     * Error codes this plugin may raise, folded into the registry.
-     *
-     * Registration is part of the contract because the error catalog is
-     * generated — a plugin that invents untyped errors would silently punch a
-     * hole in the published reference.
-     */
-    readonly errorCodes?: Readonly<Record<string, ErrorCodeSpec>>;
-    /** Which pipeline stage this plugin attaches to, if it observes deltas. */
-    readonly stage?: PipelineStage;
-    /** Build the plugin's contribution to the client surface. */
-    init(context: PluginContext): Surface;
-}
-/** The surface a plugin list contributes, keyed by plugin id. */
-export type InstalledSurface<Plugins extends readonly AbloPlugin[]> = {
-    [P in Plugins[number] as P['id']]: P extends AbloPlugin<infer S> ? S : never;
-};
-/**
- * The plugin with the given id in a list, or `never` when absent. Sound
- * because ids are literal ({@link LiteralString}); a list typed only as
- * `AbloPlugin[]` has widened ids and resolves to `never`, so write plugin
- * lists inline for the client type to follow them.
- */
-export type PluginById<Plugins extends readonly AbloPlugin[], Id extends string> = Extract<Plugins[number], {
-    id: Id;
-}>;
-/** Collapses a union into an intersection, member by member. */
-type UnionToIntersection<U> = (U extends unknown ? (member: U) => void : never) extends (member: infer I) => void ? I : never;
-/**
- * Every surface in a plugin list, folded into the one shape that merges onto
- * the client: `[a(), b()]` contributes `ASurface & BSurface`. An empty list
- * contributes nothing (`unknown`), so intersecting it changes no type.
- */
-export type MergedSurface<Plugins extends readonly AbloPlugin[]> = [
-    Plugins[number]
-] extends [never] ? unknown : UnionToIntersection<Plugins[number] extends AbloPlugin<infer Surface> ? Surface : never>;
-/** What the selected transport can actually do, for checking `requires`. */
-export interface TransportProfile {
-    readonly duplex: boolean;
-}
-/**
- * Check a plugin list against the selected transport and build its surface.
- *
- * Both failures are configuration mistakes, so they surface here — while the
- * client is being constructed and the stack still points at the caller's own
- * setup — rather than later as a subscription that never delivers.
- */
-export declare function resolvePlugins<const Plugins extends readonly AbloPlugin[], Options = unknown>(plugins: Plugins, transport: TransportProfile, context: PluginContext<Options>): InstalledSurface<Plugins>;
-/**
- * Lays every installed plugin surface over a built client, so a plugin's
- * contributions are reachable as client members. The base always wins — a
- * plugin cannot shadow `dispose`, a model accessor, or any other member the
- * client itself defines; contributions only fill what the base leaves
- * undefined. With nothing installed the base is returned untouched.
- *
- * The second half of {@link resolvePlugins}: that call turns a list into a
- * surface, this one merges the surface onto the client the host built.
- */
-export declare function layerPluginSurface<T extends object>(base: T, installed: Record<string, unknown>): T;
-/**
- * The plugins attached to one pipeline stage, in declaration order.
- *
- * Stage order across the pipeline is fixed by {@link PIPELINE_STAGES}; this
- * returns the members of a single stage, where declaration order is the caller's
- * to choose and carries no correctness weight.
- */
-export declare function pluginsForStage(plugins: readonly AbloPlugin[], stage: PipelineStage): readonly AbloPlugin[];
-export {};

package/dist/transaction/plugin.js

@@ -1,87 +0,0 @@
-/**
- * The plugin contract (ADR 0016).
- *
- * The core is `commit` · `get`/`list` · `observe` · `claim` · auth. Everything
- * else a caller might want — a local materialised copy, presence rendering,
- * batching, framework bindings — is a plugin declared in one list, so a server
- * or an agent installs only what it asked for.
- *
- * Every plugin has the same shape on purpose. Uniformity is what makes the list
- * composable and the types inferable; bespoke plugins would reproduce today's
- * nineteen export subpaths with extra ceremony.
- *
- * Where this shape came from, and the field-by-field reasoning behind it, is
- * recorded in ADR 0016 — the contract itself only states what each field does.
- */
-import { AbloValidationError } from './errors.js';
-/** Canonical order. A plugin runner must run stages in this sequence. */
-export const PIPELINE_STAGES = [
-    'receive',
-    'dedupe',
-    'persist',
-    'apply',
-    'acknowledge',
-    'notify',
-];
-/**
- * Check a plugin list against the selected transport and build its surface.
- *
- * Both failures are configuration mistakes, so they surface here — while the
- * client is being constructed and the stack still points at the caller's own
- * setup — rather than later as a subscription that never delivers.
- */
-export function resolvePlugins(plugins, transport, context) {
-    const surface = {};
-    const seen = new Set();
-    for (const plugin of plugins) {
-        if (seen.has(plugin.id)) {
-            throw new AbloValidationError(`The ${plugin.id} plugin is listed twice. Remove the duplicate; a plugin is installed once per client.`, { code: 'invalid_options', param: 'plugins' });
-        }
-        seen.add(plugin.id);
-        if (plugin.requires?.duplex && !transport.duplex) {
-            throw new AbloValidationError(`The ${plugin.id} plugin needs a connection the server can send on, and this client is set up for request-response only. Switch the transport to 'websocket', or drop the plugin.`, { code: 'invalid_options', param: 'plugins' });
-        }
-        surface[plugin.id] = plugin.init(context);
-    }
-    return surface;
-}
-/**
- * Lays every installed plugin surface over a built client, so a plugin's
- * contributions are reachable as client members. The base always wins — a
- * plugin cannot shadow `dispose`, a model accessor, or any other member the
- * client itself defines; contributions only fill what the base leaves
- * undefined. With nothing installed the base is returned untouched.
- *
- * The second half of {@link resolvePlugins}: that call turns a list into a
- * surface, this one merges the surface onto the client the host built.
- */
-export function layerPluginSurface(base, installed) {
-    const contributions = {};
-    for (const surface of Object.values(installed)) {
-        if (surface && typeof surface === 'object') {
-            Object.assign(contributions, surface);
-        }
-    }
-    if (Object.keys(contributions).length === 0)
-        return base;
-    return new Proxy(base, {
-        get(target, prop, receiver) {
-            const own = Reflect.get(target, prop, receiver);
-            if (own !== undefined)
-                return own;
-            return typeof prop === 'string' && prop in contributions
-                ? contributions[prop]
-                : own;
-        },
-    });
-}
-/**
- * The plugins attached to one pipeline stage, in declaration order.
- *
- * Stage order across the pipeline is fixed by {@link PIPELINE_STAGES}; this
- * returns the members of a single stage, where declaration order is the caller's
- * to choose and carries no correctness weight.
- */
-export function pluginsForStage(plugins, stage) {
-    return plugins.filter((plugin) => plugin.stage === stage);
-}