@abloatai/ablo 0.10.0 → 0.11.0

package/dist/sync/awaitIntentGrant.js

@@ -1,62 +0,0 @@
-/**
- * `awaitIntentGrant` — the client side of the fair-queue handover.
- *
- * When a `claim` is contended, the server enqueues it and replies `queued`
- * (HTTP 202 on `/v1/intents`, or `intent_queued` over WS). The grant is then
- * PUSHED later over the WS as `intent_granted` when the claim reaches the head.
- * This resolves once that frame arrives for our `intentId` — so the caller's
- * `claim` promise stays pending (event-driven; no poll, no race) until it's
- * actually our turn. Rejects on `intent_lost` (surfaced as `claim_lost`: the claim was taken away — TTL
- * lapse on disconnect, revoke) or an optional timeout.
- *
- * Takes only a minimal `{ subscribe }` transport so it unit-tests against a
- * fake; `SyncWebSocket` satisfies it structurally.
- */
-import { AbloClaimedError } from '../errors.js';
-export function awaitIntentGrant(transport, intentId, options) {
-    return new Promise((resolve, reject) => {
-        const unsubs = [];
-        let timer;
-        const settle = (fn) => {
-            if (timer)
-                clearTimeout(timer);
-            for (const u of unsubs)
-                u();
-            fn();
-        };
-        // The target was free → `intent_acquired` (immediate); it was contended,
-        // we waited in line, and reached the head → `intent_granted`. Either frame
-        // means the lease is now ours; `waited` records which path it was.
-        unsubs.push(transport.subscribe('intent_acquired', (p) => {
-            if (p?.intentId === intentId)
-                settle(() => resolve({ waited: false }));
-        }));
-        unsubs.push(transport.subscribe('intent_granted', (p) => {
-            if (p?.intentId === intentId)
-                settle(() => resolve({ waited: true }));
-        }));
-        if (options?.maxQueueDepth !== undefined) {
-            const max = options.maxQueueDepth;
-            unsubs.push(transport.subscribe('intent_queued', (p) => {
-                if (p?.intentId !== intentId)
-                    return;
-                const position = typeof p.position === 'number' ? p.position : 0;
-                if (position >= max) {
-                    settle(() => reject(new AbloClaimedError(`Claim queue for ${intentId} is ${position} deep (max ${max}).`, { code: 'queue_too_deep' })));
-                }
-            }));
-        }
-        unsubs.push(transport.subscribe('intent_lost', (p) => {
-            if (p?.intentId === intentId) {
-                settle(() => reject(new AbloClaimedError(`Claim lost while queued for ${intentId}.`, {
-                    code: 'claim_lost',
-                })));
-            }
-        }));
-        if (options?.timeoutMs && options.timeoutMs > 0) {
-            timer = setTimeout(() => {
-                settle(() => reject(new AbloClaimedError(`Timed out waiting for the queue grant on claim ${intentId}.`, { code: 'grant_timeout' })));
-            }, options.timeoutMs);
-        }
-    });
-}

package/dist/sync/createIntentStream.d.ts

@@ -1,34 +0,0 @@
-/**
- * Transport-driven IntentStream factory.
- *
- * Mirrors `createPresenceStream` — built directly on `SyncWebSocket`,
- * no SyncAgent wrapper. Intents derive their `others` view from the
- * same `presence_update` frames the presence stream consumes (the
- * Hub piggybacks `activeIntents` on every presence frame). Outbound
- * announce/revoke ride the same socket via `intent_begin` /
- * `intent_abandon` frames.
- *
- * Wire contract (apps/sync-server/src/hub/types.ts):
- *   • Outbound: `{ type: 'intent_begin', payload: { intentId,
- *       entityType, entityId, action, field?, estimatedMs? } }`
- *   • Outbound: `{ type: 'intent_abandon', payload: { intentId,
- *       entityType?, entityId? } }`
- *   • Inbound (via presence): `event.activeIntents: IntentClaim[]`
- *     stamped with `declaredAt`, `expiresAt`.
- *   • Inbound: `intent_rejected` event with conflict metadata.
- *
- * After the dual-engine collapse (step #36), this is the only
- * IntentStream factory in the SDK; the older compatibility path
- * deletes.
- */
-import type { SyncWebSocket } from './SyncWebSocket.js';
-import type { IntentStream } from '../types/streams.js';
-export interface IntentStreamConfig {
-    /** Identity used to filter our own active intents out of `others`. */
-    participantId: string;
-}
-export interface AttachableIntentStream extends IntentStream {
-    attach(transport: SyncWebSocket): void;
-    dispose(): void;
-}
-export declare function createIntentStream(config: IntentStreamConfig, transport?: SyncWebSocket | null): AttachableIntentStream;