@abloatai/ablo 0.36.0 → 0.37.1

package/dist/sync/schemas.d.ts

@@ -1,71 +0,0 @@
-/**
- * Zod validation schemas for sync engine server responses.
- *
- * Validates data at the fetch boundary before it enters the sync engine.
- * Unknown keys are kept, so a server that adds a field does not break a client
- * that predates it.
- */
-import { z } from 'zod';
-import type { RuntimeContext } from "../RuntimeContext.js";
-/**
- * A delta as it arrives in a bootstrap payload.
- *
- * The bootstrap routes return the same rows the broadcast path does, so the
- * fields are taken from {@link syncDeltaWireCoreSchema} rather than restated
- * here — a delta is one shape, and this is the reader for it, not a second
- * definition of it. Unknown keys are kept, because the server sends its own
- * wider projection (attribution, `projectId`) that later stages may read.
- */
-export declare const ServerDeltaSchema: z.ZodObject<{
-    id: z.ZodNumber;
-    data: z.ZodNullable<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodString]>>;
-    actionType: z.ZodEnum<{
-        I: "I";
-        U: "U";
-        D: "D";
-        A: "A";
-        V: "V";
-        C: "C";
-        G: "G";
-        S: "S";
-    }>;
-    modelName: z.ZodString;
-    modelId: z.ZodString;
-}, z.core.$loose>;
-export type ValidatedServerDelta = z.infer<typeof ServerDeltaSchema>;
-export declare const BootstrapResponseSchema: z.ZodObject<{
-    type: z.ZodEnum<{
-        full: "full";
-        partial: "partial";
-    }>;
-    lastSyncId: z.ZodNumber;
-    models: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodString, z.ZodNull]>, z.ZodTransform<unknown[], string | unknown[] | null>>>>;
-    deltas: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        id: z.ZodNumber;
-        data: z.ZodNullable<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodString]>>;
-        actionType: z.ZodEnum<{
-            I: "I";
-            U: "U";
-            D: "D";
-            A: "A";
-            V: "V";
-            C: "C";
-            G: "G";
-            S: "S";
-        }>;
-        modelName: z.ZodString;
-        modelId: z.ZodString;
-    }, z.core.$loose>>>;
-    deltaCount: z.ZodOptional<z.ZodNumber>;
-    failedModels: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    timestamp: z.ZodDefault<z.ZodNumber>;
-    schemaHash: z.ZodOptional<z.ZodString>;
-    nextCursor: z.ZodOptional<z.ZodString>;
-}, z.core.$loose>;
-export type ValidatedBootstrapResponse = z.infer<typeof BootstrapResponseSchema>;
-/**
- * Validates a raw bootstrap response from the server and returns the typed
- * result. On failure it records a diagnostic breadcrumb and throws an
- * {@link AbloValidationError} describing which fields were invalid.
- */
-export declare function parseBootstrapResponse(raw: unknown, runtime?: RuntimeContext): ValidatedBootstrapResponse;

package/dist/sync/schemas.js

@@ -1,94 +0,0 @@
-/**
- * Zod validation schemas for sync engine server responses.
- *
- * Validates data at the fetch boundary before it enters the sync engine.
- * Unknown keys are kept, so a server that adds a field does not break a client
- * that predates it.
- */
-import { z } from 'zod';
-import { globalRuntime } from "../context.js";
-import { AbloValidationError } from "../transaction/errors.js";
-import { syncDeltaWireCoreSchema } from '../transaction/wire/delta.js';
-// ─── Server Delta Schema ─────────────────────────────────────────────────────
-/**
- * A delta as it arrives in a bootstrap payload.
- *
- * The bootstrap routes return the same rows the broadcast path does, so the
- * fields are taken from {@link syncDeltaWireCoreSchema} rather than restated
- * here — a delta is one shape, and this is the reader for it, not a second
- * definition of it. Unknown keys are kept, because the server sends its own
- * wider projection (attribution, `projectId`) that later stages may read.
- */
-export const ServerDeltaSchema = syncDeltaWireCoreSchema
-    .pick({
-    id: true,
-    actionType: true,
-    modelName: true,
-    modelId: true,
-    data: true,
-})
-    .loose();
-// ─── Model Value Schema ─────────────────────────────────────────────────────
-// A model's values can arrive in more than one shape depending on how the
-// server serialized them:
-//   - Array: an already-parsed JSON array (the common case)
-//   - String: a JSON array still encoded as a string, which must be parsed
-//   - null: no matching rows
-// This schema normalizes every variant into an array before downstream use.
-const ModelValueSchema = z
-    .union([z.array(z.unknown()), z.string(), z.null()])
-    .transform((val) => {
-    if (val === null)
-        return [];
-    if (typeof val === 'string') {
-        try {
-            const parsed = JSON.parse(val);
-            return Array.isArray(parsed) ? parsed : [];
-        }
-        catch {
-            return [];
-        }
-    }
-    return val;
-});
-// ─── Bootstrap Response Schema ───────────────────────────────────────────────
-export const BootstrapResponseSchema = z
-    .object({
-    type: z.enum(['full', 'partial']),
-    lastSyncId: z.number(),
-    models: z.record(z.string(), ModelValueSchema).optional(),
-    deltas: z.array(ServerDeltaSchema).optional(),
-    deltaCount: z.number().optional(),
-    failedModels: z.array(z.string()).optional(),
-    timestamp: z.number().default(() => Date.now()),
-    // The server's active schema hash, used to detect schema drift. Optional:
-    // absent when the server predates this field or the tenant has never
-    // pushed a schema.
-    schemaHash: z.string().optional(),
-    // Present when a paged single-model request stopped at its row limit
-    // with rows remaining: pass it back as the next page's cursor. Absent
-    // on the final page, on unpaged responses, and from older servers.
-    nextCursor: z.string().optional(),
-})
-    .loose();
-// ─── Parse Helpers ───────────────────────────────────────────────────────────
-/**
- * Validates a raw bootstrap response from the server and returns the typed
- * result. On failure it records a diagnostic breadcrumb and throws an
- * {@link AbloValidationError} describing which fields were invalid.
- */
-export function parseBootstrapResponse(raw, runtime = globalRuntime) {
-    const result = BootstrapResponseSchema.safeParse(raw);
-    if (!result.success) {
-        const issues = result.error.issues.map((i) => `${i.path.join('.')}: ${i.message}`).join('; ');
-        runtime.observability.breadcrumb('Bootstrap response validation failed', 'sync.bootstrap', 'error', {
-            issues,
-            rawType: typeof raw,
-            rawKeys: raw && typeof raw === 'object' ? Object.keys(raw).join(',') : 'n/a',
-        });
-        throw new AbloValidationError(`Invalid bootstrap response: ${issues}`, {
-            code: 'bootstrap_response_schema_invalid',
-        });
-    }
-    return result.data;
-}

package/dist/sync/syncCursor.d.ts

@@ -1,40 +0,0 @@
-/**
- * Holds the resume state of one WebSocket sync session: the `lastSyncId`
- * watermark, which marks the highest delta the client has seen, and an opaque
- * server cursor used for incremental sync. The transport carries both across
- * reconnects so the session can resume where it left off.
- *
- * The watermark advances under a strict rule — it moves forward only on an
- * acknowledgement that is gated on durable persistence — which the transport
- * enforces at its acknowledgement and delta-handling call sites.
- */
-export declare class SyncCursor {
-    lastSyncId: number;
-    syncCursor: string | null;
-    constructor(lastSyncId: number);
-    /**
-     * Advances the watermark in response to an acknowledgement. This becomes the
-     * value the next incremental-sync request and the connect handshake send, and
-     * the value {@link SyncCursor.getLastSyncId} reports when persisting on a
-     * clean shutdown. The move is monotonic: a stale, lower acknowledgement never
-     * pulls the watermark backward.
-     */
-    ackAdvance(syncId: number): void;
-    /**
-     * Sets the watermark outright, used when restoring persisted state.
-     */
-    setLastSyncId(syncId: number): void;
-    /**
-     * Sets the opaque server cursor used for incremental sync.
-     */
-    setSyncCursor(cursor: string | null): void;
-    /**
-     * Returns the current opaque server cursor, or null if none is set.
-     */
-    getSyncCursor(): string | null;
-    /**
-     * Returns the highest delta id seen this session, for persistence on a clean
-     * shutdown.
-     */
-    getLastSyncId(): number;
-}

package/dist/sync/syncCursor.js

@@ -1,55 +0,0 @@
-/**
- * Holds the resume state of one WebSocket sync session: the `lastSyncId`
- * watermark, which marks the highest delta the client has seen, and an opaque
- * server cursor used for incremental sync. The transport carries both across
- * reconnects so the session can resume where it left off.
- *
- * The watermark advances under a strict rule — it moves forward only on an
- * acknowledgement that is gated on durable persistence — which the transport
- * enforces at its acknowledgement and delta-handling call sites.
- */
-export class SyncCursor {
-    lastSyncId;
-    syncCursor;
-    constructor(lastSyncId) {
-        this.lastSyncId = lastSyncId;
-        this.syncCursor = null;
-    }
-    /**
-     * Advances the watermark in response to an acknowledgement. This becomes the
-     * value the next incremental-sync request and the connect handshake send, and
-     * the value {@link SyncCursor.getLastSyncId} reports when persisting on a
-     * clean shutdown. The move is monotonic: a stale, lower acknowledgement never
-     * pulls the watermark backward.
-     */
-    ackAdvance(syncId) {
-        if (syncId > this.lastSyncId) {
-            this.lastSyncId = syncId;
-        }
-    }
-    /**
-     * Sets the watermark outright, used when restoring persisted state.
-     */
-    setLastSyncId(syncId) {
-        this.lastSyncId = syncId;
-    }
-    /**
-     * Sets the opaque server cursor used for incremental sync.
-     */
-    setSyncCursor(cursor) {
-        this.syncCursor = cursor;
-    }
-    /**
-     * Returns the current opaque server cursor, or null if none is set.
-     */
-    getSyncCursor() {
-        return this.syncCursor;
-    }
-    /**
-     * Returns the highest delta id seen this session, for persistence on a clean
-     * shutdown.
-     */
-    getLastSyncId() {
-        return this.lastSyncId || 0;
-    }
-}

package/dist/sync/syncPlan.d.ts

@@ -1,54 +0,0 @@
-/**
- * Derives a client's sync plan from its {@link Schema}. Walking the schema's
- * models and relations, it produces two declarative arrays consumed when the
- * store is constructed: the foreign-key indexes to register on the in-memory
- * object pool, and the enrichment rules that attach related parents to
- * incoming rows. See {@link deriveSyncPlanFromSchema}.
- */
-import type { Schema } from '../transaction/schema/schema.js';
-/** A foreign-key index to register on the in-memory object pool when the store is constructed. */
-export interface ForeignKeyIndexSpec {
-    /**
-     * The name of the child model, where the foreign-key field lives, and the
-     * name the object pool indexes by. Use the wire type-name casing (for
-     * example `'Block'`, not `'block'`), since that is the value
-     * stamped onto reconstructed models and the key the pool looks up.
-     */
-    readonly modelName: string;
-    /** The foreign-key field name on the child model, for example `'sectionId'`. */
-    readonly fieldName: string;
-}
-/**
- * A declarative rule for enriching an incoming row with its related parent.
- *
- * When a delta for `modelName` arrives and its row has been constructed, the
- * store reads the row's `foreignKey` value, looks up the matching parent in
- * the object pool, and attaches it under `relationKey`. Enrichment is
- * best-effort: if the parent is not in the pool yet — for example, it arrives
- * later in the same bootstrap batch — the step is skipped without error.
- */
-export interface EnrichmentPlanEntry {
-    /** The child model whose incoming deltas should be enriched. */
-    readonly modelName: string;
-    /** The foreign-key field on the child that points at the parent's id. */
-    readonly foreignKey: string;
-    /** The property name under which to attach the parent model. */
-    readonly relationKey: string;
-}
-/**
- * Walks a schema and derives the two sync-plan arrays used when the store is
- * constructed: the foreign-key indexes to register on the object pool and the
- * enrichment plan. See {@link ForeignKeyIndexSpec} and
- * {@link EnrichmentPlanEntry}.
- *
- * Both are drawn from each `belongsTo` relation that sets `options.index` or
- * `options.enrich`; relations without those options are skipped. Enabling them
- * is opt-in, so adding a `belongsTo` relation never silently changes how deltas
- * apply or how lookups resolve. A `hasMany` or `hasOne` relation registers its
- * index on the target model, since that is where the foreign key lives. The
- * function has no side effects and is called once at construction.
- */
-export declare function deriveSyncPlanFromSchema(schema: Schema): {
-    enrichmentPlan: EnrichmentPlanEntry[];
-    foreignKeyIndexes: ForeignKeyIndexSpec[];
-};

package/dist/sync/syncPlan.js

@@ -1,50 +0,0 @@
-/**
- * Derives a client's sync plan from its {@link Schema}. Walking the schema's
- * models and relations, it produces two declarative arrays consumed when the
- * store is constructed: the foreign-key indexes to register on the in-memory
- * object pool, and the enrichment rules that attach related parents to
- * incoming rows. See {@link deriveSyncPlanFromSchema}.
- */
-/**
- * Walks a schema and derives the two sync-plan arrays used when the store is
- * constructed: the foreign-key indexes to register on the object pool and the
- * enrichment plan. See {@link ForeignKeyIndexSpec} and
- * {@link EnrichmentPlanEntry}.
- *
- * Both are drawn from each `belongsTo` relation that sets `options.index` or
- * `options.enrich`; relations without those options are skipped. Enabling them
- * is opt-in, so adding a `belongsTo` relation never silently changes how deltas
- * apply or how lookups resolve. A `hasMany` or `hasOne` relation registers its
- * index on the target model, since that is where the foreign key lives. The
- * function has no side effects and is called once at construction.
- */
-export function deriveSyncPlanFromSchema(schema) {
-    const enrichmentPlan = [];
-    const foreignKeyIndexes = [];
-    for (const [modelName, def] of Object.entries(schema.models)) {
-        const typename = def.typename ?? modelName;
-        for (const [relationKey, rel] of Object.entries(def.relations)) {
-            if (rel.type === 'belongsTo') {
-                if (rel.options?.index) {
-                    foreignKeyIndexes.push({ modelName: typename, fieldName: rel.foreignKey });
-                }
-                if (rel.options?.enrich) {
-                    enrichmentPlan.push({
-                        modelName: typename,
-                        foreignKey: rel.foreignKey,
-                        relationKey,
-                    });
-                }
-            }
-            else if (rel.type === 'hasMany' || rel.type === 'hasOne') {
-                // For hasMany and hasOne, the foreign key lives on the target model,
-                // not the current one, so register the index on the target. Its wire
-                // type name is resolved from the schema here.
-                const targetDef = schema.models[rel.target];
-                const targetTypename = targetDef?.typename ?? rel.target;
-                foreignKeyIndexes.push({ modelName: targetTypename, fieldName: rel.foreignKey });
-            }
-        }
-    }
-    return { enrichmentPlan, foreignKeyIndexes };
-}

package/dist/sync/wsFrameHandlers.d.ts

@@ -1,8 +0,0 @@
-/**
- * Moved to the settlement core with the duplex transport (ADR 0016): the
- * inbound frame dispatch is the receiving half of the wire protocol, and the
- * handlers already worked against the minimal `WsSession` port rather than
- * the transport object. This path re-exports it so existing importers stay
- * unchanged.
- */
-export { isRecord, readWsInboundFrame, wsFrameHandlers, dispatchWsFrame, type PendingCommit, type PendingClaim, type PendingSubscription, type WsInboundFrame, type WsSession, type WsFrameHandler, } from '../transaction/transport/wsFrameHandlers.js';

package/dist/sync/wsFrameHandlers.js

@@ -1,8 +0,0 @@
-/**
- * Moved to the settlement core with the duplex transport (ADR 0016): the
- * inbound frame dispatch is the receiving half of the wire protocol, and the
- * handlers already worked against the minimal `WsSession` port rather than
- * the transport object. This path re-exports it so existing importers stay
- * unchanged.
- */
-export { isRecord, readWsInboundFrame, wsFrameHandlers, dispatchWsFrame, } from '../transaction/transport/wsFrameHandlers.js';

package/dist/syncLog/contract.d.ts

@@ -1,20 +0,0 @@
-/** Canonical sync-log identity and position contracts shared by client/server. */
-import { z } from 'zod';
-export declare const deltaPositionSchema: z.ZodNumber;
-export type DeltaPosition = z.infer<typeof deltaPositionSchema>;
-export declare const clientMutationIdSchema: z.ZodString;
-export type ClientMutationId = z.infer<typeof clientMutationIdSchema>;
-export declare const sourceCorrelationIdSchema: z.ZodString;
-export type SourceCorrelationId = z.infer<typeof sourceCorrelationIdSchema>;
-export declare const sourceChangeIdSchema: z.ZodString;
-export type SourceChangeId = z.infer<typeof sourceChangeIdSchema>;
-export declare const replicationLsnSchema: z.ZodString;
-export type ReplicationLSN = z.infer<typeof replicationLsnSchema>;
-export declare const commitDispatchMarkerSchema: z.ZodObject<{
-    kind: z.ZodLiteral<"sync_deltas">;
-    organizationId: z.ZodString;
-    environment: z.ZodString;
-    firstSyncId: z.ZodNumber;
-    lastSyncId: z.ZodNumber;
-}, z.core.$strict>;
-export type CommitDispatchMarker = z.infer<typeof commitDispatchMarkerSchema>;

package/dist/syncLog/contract.js

@@ -1,19 +0,0 @@
-/** Canonical sync-log identity and position contracts shared by client/server. */
-import { z } from 'zod';
-import { environmentSchema } from '../environment.js';
-export const deltaPositionSchema = z.number().int().nonnegative().safe();
-export const clientMutationIdSchema = z.string().min(1).max(255);
-export const sourceCorrelationIdSchema = z.string().min(1).max(255);
-export const sourceChangeIdSchema = z.string().min(1).max(512);
-export const replicationLsnSchema = z.string().regex(/^[0-9A-Fa-f]+\/[0-9A-Fa-f]+$/);
-export const commitDispatchMarkerSchema = z.strictObject({
-    kind: z.literal('sync_deltas'),
-    organizationId: z.string().min(1),
-    environment: environmentSchema,
-    firstSyncId: deltaPositionSchema,
-    lastSyncId: deltaPositionSchema,
-}).superRefine((value, ctx) => {
-    if (value.firstSyncId <= 0 || value.lastSyncId < value.firstSyncId) {
-        ctx.addIssue({ code: 'custom', message: 'invalid delta position range' });
-    }
-});

package/dist/syncLog/index.d.ts

@@ -1 +0,0 @@
-export * from './contract.js';

package/dist/syncLog/index.js

@@ -1 +0,0 @@
-export * from './contract.js';

package/dist/transaction/ablo.d.ts

@@ -1,88 +0,0 @@
-/**
- * `Ablo` — the entry point to the coordination layer.
- *
- * The factory constructs the stateless client: typed model resources, commits,
- * claims, and session minting over request/response HTTP. It holds no socket,
- * no store, and no local copy of anything — the bearer credential is the
- * identity and the server resolves it on every request. This is the client a
- * server-side actor installs: an agent, a worker, a cron job, a route handler.
- *
- * ```ts
- * import { Ablo } from '@abloatai/ablo';
- * import { schema } from './schema';
- *
- * const ablo = Ablo({ schema, apiKey: process.env.ABLO_API_KEY, transport: 'http' });
- * await ablo.tasks.update({ id: taskId, data: { status: 'done' } });
- * ```
- *
- * The reactive materialiser — local store, live queries, presence rendering —
- * is the consumer package's entry point (`@abloatai/ablo`), which layers
- * above this one and shares the same `ablo.<model>` surface (ADR 0016).
- */
-import { type AbloHttpClient, type AbloHttpClientOptions } from './transport/httpClient.js';
-import type { SchemaRecord } from './schema/schema.js';
-import type * as _Streams from './types/streams.js';
-import type * as _SchemaTypes from './schema/schema.js';
-import type * as _Global from './types/global.js';
-import type * as _Policy from './policy/types.js';
-import type * as _Http from './resources/httpResources.js';
-/**
- * Create a coordination-layer client in one call.
- *
- * The core carries one transport today — request/response HTTP — so
- * `transport: 'http'` is accepted for symmetry with the reactive package's
- * factory and may be omitted. The duplex transport joins this slot when the
- * socket carve lands (ADR 0016, follow-up 3a).
- */
-export declare function Ablo<const S extends SchemaRecord>(options: AbloHttpClientOptions<S> & {
-    transport?: 'http';
-}): AbloHttpClient<S>;
-export declare namespace Ablo {
-    type ClaimTarget = _Streams.ClaimTarget;
-    type PresenceTarget = _Streams.PresenceTarget;
-    type Duration = _Streams.Duration;
-    type Peer = _Streams.Peer;
-    type Activity = _Streams.Activity;
-    type Claim = _Streams.Claim;
-    type ClaimHeartbeat = _Streams.ClaimHeartbeat;
-    type ClaimHeartbeatOptions = _Streams.ClaimHeartbeatOptions;
-    namespace Claim {
-        type Held<T = Record<string, unknown>, M = _Global.ResolveClaimMeta> = _Streams.HeldClaim<T, M>;
-        type WaitOptions = _Streams.ClaimWaitOptions;
-        type LeaseOptions = _Streams.ClaimLeaseOptions;
-    }
-    type Schema<S extends _SchemaTypes.SchemaRecord = _SchemaTypes.SchemaRecord> = _SchemaTypes.Schema<S>;
-    /**
-     * The schema this program has registered via `interface Register { Schema }`
-     * (falls back to a loose shape when unregistered). Use it where shared code
-     * needs "this app's schema" without importing a specific one.
-     */
-    type ResolveSchema = _Global.ResolveSchema;
-    /**
-     * The claim metadata shape this program has registered via
-     * `interface Register { ClaimMeta }` (falls back to a loose record when
-     * unregistered). Every claim surface reads `target.meta` as this.
-     */
-    type ResolveClaimMeta = _Global.ResolveClaimMeta;
-    namespace Schema {
-        type Model<S extends _SchemaTypes.Schema, K extends keyof S['models']> = _SchemaTypes.Model<S, K>;
-        type InferCreate<S extends _SchemaTypes.Schema, K extends keyof S['models']> = _SchemaTypes.InferCreate<S, K>;
-        type InferModelNames<S extends _SchemaTypes.Schema> = _SchemaTypes.InferModelNames<S>;
-    }
-    type Conflict = _Policy.Conflict;
-    namespace Conflict {
-        type Kind = _Policy.ConflictKind;
-        type Operation = _Policy.ConflictOperation;
-        type Decision = _Policy.ConflictDecision;
-        type Policy = _Policy.ConflictPolicy;
-        type Axis = _Policy.ConflictAxis;
-    }
-    namespace Commit {
-        type Wait = _Http.CommitWait;
-        type OperationAction = _Http.ModelOperationAction;
-        type OperationInput = _Http.CommitOperationInput;
-        type CreateOptions = _Http.CommitCreateOptions;
-        type Receipt = _Http.CommitReceipt;
-        type Client = _Http.CommitResource;
-    }
-}

package/dist/transaction/ablo.js

@@ -1,33 +0,0 @@
-/**
- * `Ablo` — the entry point to the coordination layer.
- *
- * The factory constructs the stateless client: typed model resources, commits,
- * claims, and session minting over request/response HTTP. It holds no socket,
- * no store, and no local copy of anything — the bearer credential is the
- * identity and the server resolves it on every request. This is the client a
- * server-side actor installs: an agent, a worker, a cron job, a route handler.
- *
- * ```ts
- * import { Ablo } from '@abloatai/ablo';
- * import { schema } from './schema';
- *
- * const ablo = Ablo({ schema, apiKey: process.env.ABLO_API_KEY, transport: 'http' });
- * await ablo.tasks.update({ id: taskId, data: { status: 'done' } });
- * ```
- *
- * The reactive materialiser — local store, live queries, presence rendering —
- * is the consumer package's entry point (`@abloatai/ablo`), which layers
- * above this one and shares the same `ablo.<model>` surface (ADR 0016).
- */
-import { createAbloHttpClient, } from './transport/httpClient.js';
-/**
- * Create a coordination-layer client in one call.
- *
- * The core carries one transport today — request/response HTTP — so
- * `transport: 'http'` is accepted for symmetry with the reactive package's
- * factory and may be omitted. The duplex transport joins this slot when the
- * socket carve lands (ADR 0016, follow-up 3a).
- */
-export function Ablo(options) {
-    return createAbloHttpClient(options);
-}