@abloatai/humans 0.59.2 → 0.61.0

package/dist/local/sync/participants.js

@@ -1,342 +0,0 @@
-import { scopeKindOf } from '@abloatai/transaction/schema/model';
-import { AbloValidationError } from '@abloatai/transaction/errors';
-import { subTarget, streamTarget, wireTarget, } from '@abloatai/transaction/coordination';
-export function createParticipantManager(config) {
-    return {
-        async join(input, overrides) {
-            const options = normalizeJoinOptions(input, overrides);
-            const target = options.focus ?? options.target
-                ? targetToEntityRef((options.focus ?? options.target))
-                : null;
-            const syncGroups = unique(resolveParticipantSyncGroups(options.scope ?? target ?? undefined, config.schema));
-            await config.ready();
-            // Not-connected joins surface through `sendClaim`'s diagnosed
-            // rejection below; a scopeless join needs no wire send at all.
-            const transport = config.transport;
-            const claimId = createParticipantClaimId();
-            if (syncGroups.length > 0) {
-                await transport.sendClaim(claimId, syncGroups, {
-                    capabilityToken: options.capabilityToken,
-                    // `ttl` is the spelling; `ttlSeconds` is the deprecated one, read
-                    // second so a caller passing both gets the current name honored.
-                    // eslint-disable-next-line @typescript-eslint/no-deprecated -- reading the deprecated alias IS the back-compat this line provides
-                    ttlSeconds: parseParticipantTtlSeconds(options.ttl ?? options.ttlSeconds),
-                });
-            }
-            const participant = createJoinedParticipant({
-                target,
-                syncGroups,
-                claimId,
-                transport,
-                presence: config.presence,
-                claims: config.claims,
-            });
-            if (target && options.activity !== false) {
-                const activity = options.activity ?? 'reading';
-                if (activity === 'editing') {
-                    participant.presence.editing(options.detail);
-                }
-                else if (activity === 'viewing') {
-                    participant.presence.viewing(options.detail);
-                }
-                else {
-                    participant.presence.reading(options.detail);
-                }
-            }
-            return participant;
-        },
-    };
-}
-export function resolveParticipantSyncGroups(scope, schema) {
-    if (!scope)
-        return [];
-    if (typeof scope === 'string')
-        return [scope];
-    if (Array.isArray(scope)) {
-        return scope.flatMap((entry) => typeof entry === 'string' ? [entry] : [syncGroupFromEntityRef(entry, schema)]);
-    }
-    const direct = scope;
-    if (isEntityScope(scope))
-        return [syncGroupFromEntityRef(scope, schema)];
-    if (typeof direct.syncGroup === 'string')
-        return [direct.syncGroup];
-    if (Array.isArray(direct.syncGroups)) {
-        return direct.syncGroups.filter((g) => typeof g === 'string');
-    }
-    const out = [];
-    for (const [key, value] of Object.entries(scope)) {
-        if (value === undefined)
-            continue;
-        if (Array.isArray(value)) {
-            for (const id of value)
-                out.push(syncGroupFromSchemaKey(key, id, schema));
-        }
-        else {
-            out.push(syncGroupFromSchemaKey(key, value, schema));
-        }
-    }
-    return out;
-}
-/**
- * The group kind for a model, in the wire dialect every plane shares: a
- * declared scope root wins; otherwise the lowercased typename — the same
- * token the commit plane and claim targets use (`wireModel`). Never the
- * camelCase schema key: the server validates inbound subscription groups
- * against a lowercase-only grammar, so a key like `reportBlocks` would be
- * rejected as malformed on subscribe — and even a lowercase key would put
- * this client in a different group than a peer who resolved the same row
- * through an entity ref, so the two would never see each other's claims.
- */
-function groupKindForModel(def, key) {
-    return scopeKindOf(def, key) ?? (def.typename ?? key).toLowerCase();
-}
-export function syncGroupFromEntityRef(ref, schema) {
-    const match = findModelForEntityRef(ref, schema);
-    const kind = match
-        ? groupKindForModel(match.def, match.key)
-        : ref.type.toLowerCase();
-    return `${kind}:${ref.id}`;
-}
-function syncGroupFromSchemaKey(schemaKey, id, schema) {
-    const def = schema?.models?.[schemaKey];
-    const kind = def ? groupKindForModel(def, schemaKey) : schemaKey.toLowerCase();
-    return `${kind}:${id}`;
-}
-function findModelForEntityRef(ref, schema) {
-    if (!schema?.models)
-        return null;
-    const wanted = ref.type.toLowerCase();
-    for (const [key, def] of Object.entries(schema.models)) {
-        const typename = def.typename ?? key;
-        if (typename.toLowerCase() === wanted || key.toLowerCase() === wanted) {
-            return { key, def };
-        }
-    }
-    return null;
-}
-export function parseParticipantTtlSeconds(value) {
-    if (typeof value === 'number' && Number.isFinite(value))
-        return value;
-    if (!value)
-        return undefined;
-    if (typeof value !== 'string')
-        return undefined;
-    const match = /^(\d+(?:\.\d+)?)(ms|s|m|h)?$/.exec(value.trim());
-    if (!match)
-        return undefined;
-    const amount = Number(match[1]);
-    const unit = match[2] ?? 's';
-    if (unit === 'ms')
-        return Math.max(1, Math.ceil(amount / 1000));
-    if (unit === 'm')
-        return Math.ceil(amount * 60);
-    if (unit === 'h')
-        return Math.ceil(amount * 3600);
-    return Math.ceil(amount);
-}
-export function createParticipantClaimId() {
-    if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
-        return `participant:${crypto.randomUUID()}`;
-    }
-    return `participant:${Date.now()}:${Math.random().toString(36).slice(2)}`;
-}
-function normalizeJoinOptions(input, overrides) {
-    if (isTupleTarget(input) || isEntityScope(input)) {
-        return { ...overrides, target: input };
-    }
-    return { ...input, ...overrides };
-}
-function isTupleTarget(value) {
-    return (Array.isArray(value) &&
-        typeof value[0] === 'string' &&
-        typeof value[1] === 'string');
-}
-function isEntityScope(scope) {
-    return (typeof scope === 'object' &&
-        scope !== null &&
-        !Array.isArray(scope) &&
-        typeof scope.type === 'string' &&
-        typeof scope.id === 'string');
-}
-function targetToEntityRef(target) {
-    if (isTupleTarget(target))
-        return { type: target[0], id: target[1] };
-    return target;
-}
-function unique(values) {
-    return [...new Set(values)];
-}
-function createJoinedParticipant(args) {
-    const ownHandles = new Set();
-    let currentTarget = args.target;
-    let left = false;
-    const requireTarget = (target) => {
-        const resolved = target ? targetToEntityRef(target) : currentTarget;
-        if (!resolved) {
-            throw new AbloValidationError('Participant action requires a structured target', {
-                code: 'invalid_request',
-            });
-        }
-        return resolved;
-    };
-    const setFocus = (target, options) => {
-        currentTarget = targetToEntityRef(target);
-        if (options?.activity === 'editing') {
-            scopedPresence.editing(options.detail);
-        }
-        else if (options?.activity === 'viewing') {
-            scopedPresence.viewing(options.detail);
-        }
-        else if (options?.activity === 'reading') {
-            scopedPresence.reading(options.detail);
-        }
-        return joined;
-    };
-    const resolvePresenceAction = (targetOrDetail, detail) => {
-        if (typeof targetOrDetail === 'string' || targetOrDetail === undefined) {
-            return { target: requireTarget(), detail: targetOrDetail ?? detail };
-        }
-        return { target: requireTarget(targetOrDetail), detail };
-    };
-    const scopedPresence = {
-        get self() {
-            return args.presence.self;
-        },
-        get focus() {
-            return currentTarget;
-        },
-        get others() {
-            return args.presence.others.filter((entry) => presenceMatchesParticipant(entry, currentTarget, args.syncGroups));
-        },
-        update(activity) {
-            args.presence.update(activity);
-        },
-        reading(targetOrDetail, detail) {
-            const action = resolvePresenceAction(targetOrDetail, detail);
-            args.presence.update({
-                ...activityFromTarget(action.target),
-                action: 'reading',
-                detail: action.detail,
-            });
-        },
-        viewing(targetOrDetail, detail) {
-            const action = resolvePresenceAction(targetOrDetail, detail);
-            args.presence.viewing(action.target, action.detail);
-        },
-        editing(targetOrDetail, detail) {
-            const action = resolvePresenceAction(targetOrDetail, detail);
-            args.presence.editing(action.target, action.detail);
-        },
-        idle() {
-            args.presence.idle();
-        },
-        onChange(listener) {
-            return args.presence.onChange(listener);
-        },
-    };
-    const track = (handle) => {
-        ownHandles.add(handle);
-        return {
-            object: 'claim',
-            id: handle.id,
-            description: handle.description,
-            target: handle.target,
-            async release() {
-                ownHandles.delete(handle);
-                await handle.release?.();
-            },
-            revoke() {
-                ownHandles.delete(handle);
-                handle.revoke?.();
-            },
-            [Symbol.asyncDispose]: async () => {
-                ownHandles.delete(handle);
-                await handle[Symbol.asyncDispose]?.();
-            },
-        };
-    };
-    const scopedClaims = {
-        get focus() {
-            return currentTarget;
-        },
-        get others() {
-            return args.claims.others.filter((claim) => currentTarget ? targetsOverlap(claim.target, currentTarget) : true);
-        },
-        claim(opts) {
-            return track(args.claims.claim(requireTarget(opts?.target), {
-                description: opts?.description,
-                ttl: opts?.ttl,
-            }));
-        },
-        onRejected(listener) {
-            return args.claims.onRejected(listener);
-        },
-        onChange(listener) {
-            return args.claims.onChange(listener);
-        },
-    };
-    const leave = () => {
-        if (left)
-            return;
-        left = true;
-        for (const handle of Array.from(ownHandles)) {
-            handle.revoke?.();
-            ownHandles.delete(handle);
-        }
-        args.presence.idle();
-        if (args.syncGroups.length > 0) {
-            args.transport.sendRelease(args.claimId);
-        }
-    };
-    const joined = {
-        get target() {
-            return currentTarget;
-        },
-        get focusTarget() {
-            return currentTarget;
-        },
-        syncGroups: [...args.syncGroups],
-        presence: scopedPresence,
-        claims: scopedClaims,
-        get peers() {
-            return scopedPresence.others;
-        },
-        get activeClaims() {
-            return scopedClaims.others;
-        },
-        focus: setFocus,
-        leave,
-        [Symbol.asyncDispose]: async () => {
-            leave();
-        },
-    };
-    return joined;
-}
-function activityFromTarget(target) {
-    return {
-        ...wireTarget(target),
-        ...subTarget(target),
-    };
-}
-function presenceMatchesParticipant(entry, target, syncGroups) {
-    if (syncGroups.some((g) => entry.syncGroups.includes(g)))
-        return true;
-    if (!target)
-        return true;
-    return targetsOverlap({
-        ...streamTarget(entry.activity),
-        ...subTarget(entry.activity),
-    }, target);
-}
-function targetsOverlap(a, b) {
-    if (a.type !== b.type || a.id !== b.id)
-        return false;
-    if (!hasSubtarget(a) || !hasSubtarget(b))
-        return true;
-    // Field is the floor: same field overlaps, different fields do not. Sub-field
-    // targeting returns when same-field concurrency (OT) is solved.
-    return !a.field || !b.field || a.field === b.field;
-}
-function hasSubtarget(target) {
-    return Boolean(target.field);
-}

package/dist/local/transactions/mutations/pendingDrain.d.ts

@@ -1,33 +0,0 @@
-import type { RuntimeContext } from '../../RuntimeContext.js';
-import type { QueuedMutation } from './commitPayload.js';
-import type { MutationStore } from './MutationStore.js';
-import type { OptimisticUpdateEntry } from './localMutation.js';
-import type { MutationCommitResult } from '@abloatai/transaction/commit';
-import type { DurableCommitEnvelope } from '@abloatai/transaction/commit';
-export interface PendingDrainContext {
-    readonly runtime: RuntimeContext;
-    readonly config: {
-        deltaConfirmationTimeout: number;
-    };
-    readonly store: MutationStore;
-    readonly executionQueue: QueuedMutation[];
-    readonly optimisticUpdates: Map<string, OptimisticUpdateEntry>;
-    readonly assertDurableReplayOpen: () => void;
-    readonly processCommitLane: () => Promise<void>;
-    readonly takePendingDrainBatch: (pending: QueuedMutation[]) => QueuedMutation[];
-    readonly ensureCommitEnvelope: (batch: QueuedMutation[]) => string;
-    readonly ensureDerivedFields: (transaction: QueuedMutation) => void;
-    readonly sourceMutationIdsFor: (batch: readonly QueuedMutation[]) => string[];
-    readonly sealDurableCommit: (input: Parameters<typeof import('./commitTransport.js').sealDurableCommit>[1]) => Promise<DurableCommitEnvelope>;
-    readonly assertEnvelopeInsideReplayWindow: (envelope: DurableCommitEnvelope) => void;
-    readonly parseMutationCommitResult: (value: Awaited<ReturnType<import('../../interfaces/index.js').MutationExecutor['commit']>>) => MutationCommitResult;
-    readonly dispatchCommitBounded: (...args: Parameters<import('../../interfaces/index.js').MutationExecutor['commit']>) => ReturnType<import('../../interfaces/index.js').MutationExecutor['commit']>;
-    readonly persistDurableCommitAcceptance: (envelope: DurableCommitEnvelope, result: MutationCommitResult) => Promise<DurableCommitEnvelope>;
-    readonly removeDurableCommit: (idempotencyKey: string) => Promise<void>;
-    readonly scheduleReplicationLagTimeout: (transactionId: string, clientTxId?: string, correlationId?: string) => void;
-    readonly scheduleDeltaConfirmationTimeout: (transaction: QueuedMutation, timeoutMs: number) => void;
-    readonly enqueue: (transaction: QueuedMutation) => void;
-    readonly recentDeltaCorrelations: Map<string, number>;
-    readonly emit: (event: string, payload: object) => boolean;
-}
-export declare function drainPendingConfirmations(ctx: PendingDrainContext): Promise<void>;

package/dist/local/transactions/mutations/pendingDrain.js

@@ -1,117 +0,0 @@
-import { applyWriteOptions, collectQueuedReads, TX_TYPE_TO_MUTATION_OP } from './commitPayload.js';
-export async function drainPendingConfirmations(ctx) {
-    ctx.assertDurableReplayOpen();
-    // Kick the commit lane too: atomic envelopes from `commits.create()` may
-    // have been left at the head of the lane while the connection was down.
-    // Fire-and-forget; processCommitLane serializes itself.
-    void ctx.processCommitLane();
-    // Collect pending transactions in created order
-    const pending = ctx.store.getByStatus('pending').sort((a, b) => a.createdAt - b.createdAt);
-    if (pending.length === 0)
-        return;
-    const pendingIds = new Set(pending.map((tx) => tx.id));
-    // These rows may already be waiting behind the normal batch timer. The
-    // reconnect fast path takes ownership of them for this attempt so the same
-    // transaction cannot dispatch concurrently through both paths.
-    const retainedQueue = ctx.executionQueue.filter((tx) => !pendingIds.has(tx.id));
-    ctx.executionQueue.splice(0, ctx.executionQueue.length, ...retainedQueue);
-    const remaining = [...pending];
-    while (remaining.length > 0) {
-        const batch = ctx.takePendingDrainBatch(remaining);
-        if (batch.length === 0)
-            break;
-        const batchIds = new Set(batch.map((tx) => tx.id));
-        const nextRemaining = remaining.filter((tx) => !batchIds.has(tx.id));
-        try {
-            const idempotencyKey = ctx.ensureCommitEnvelope(batch);
-            const projectedOperations = batch.map((tx) => {
-                ctx.ensureDerivedFields(tx);
-                return applyWriteOptions({
-                    type: TX_TYPE_TO_MUTATION_OP[tx.type],
-                    model: tx.modelKey,
-                    id: tx.modelId,
-                    input: tx.type === 'create' || tx.type === 'update' ? tx.data || {} : undefined,
-                    transactionId: tx.id,
-                }, tx);
-            });
-            const durableEnvelope = await ctx.sealDurableCommit({
-                idempotencyKey,
-                origin: 'model_batch',
-                operations: projectedOperations,
-                sourceMutationIds: ctx.sourceMutationIdsFor(batch),
-                commitOptions: { reads: collectQueuedReads(batch) },
-                createdAt: Math.min(...batch.map((transaction) => transaction.createdAt)),
-                sealedAt: batch[0]?.commitEnvelope?.sealedAt ?? Date.now(),
-                sequence: batch[0]?.commitEnvelope?.sequence,
-            });
-            ctx.assertEnvelopeInsideReplayWindow(durableEnvelope);
-            const result = ctx.parseMutationCommitResult(await ctx.dispatchCommitBounded(durableEnvelope.operations, {
-                idempotencyKey,
-                ...(durableEnvelope.commitOptions.reads !== undefined
-                    ? { reads: durableEnvelope.commitOptions.reads }
-                    : {}),
-            }));
-            await ctx.persistDurableCommitAcceptance(durableEnvelope, result);
-            if (result.status === 'queued') {
-                // Reconnect flushes use the same accepted-vs-confirmed contract as
-                // the normal lane. A queued source receipt retains the envelope and
-                // waits for exact correlation; it is never promoted by the reconnect
-                // shortcut itself.
-                for (const tx of batch) {
-                    tx.requiresCorrelatedDelta = true;
-                    tx.syncIdNeededForCompletion = undefined;
-                    tx.correlationId = result.correlationId;
-                    const echoSyncId = result.correlationId
-                        ? ctx.recentDeltaCorrelations.get(result.correlationId)
-                        : undefined;
-                    if (echoSyncId !== undefined) {
-                        ctx.store.updateStatus(tx.id, 'completed');
-                        ctx.emit('transaction:completed', tx);
-                        ctx.emit(`transaction:completed:${tx.id}`, tx);
-                        ctx.optimisticUpdates.delete(tx.id);
-                        continue;
-                    }
-                    ctx.store.updateStatus(tx.id, 'awaiting_delta');
-                    ctx.scheduleReplicationLagTimeout(tx.id, idempotencyKey, result.correlationId);
-                    ctx.scheduleDeltaConfirmationTimeout(tx, ctx.config.deltaConfirmationTimeout);
-                }
-                if (batch.every((tx) => tx.status === 'completed')) {
-                    await ctx.removeDurableCommit(idempotencyKey);
-                }
-            }
-            else {
-                await ctx.removeDurableCommit(idempotencyKey);
-                // Mark this request envelope as completed before moving to the next.
-                for (const tx of batch) {
-                    ctx.store.updateStatus(tx.id, 'completed');
-                    ctx.emit('transaction:completed', tx);
-                    ctx.emit(`transaction:completed:${tx.id}`, tx);
-                    ctx.optimisticUpdates.delete(tx.id);
-                }
-            }
-            ctx.runtime.logger.debug('txn:commit', 0, {
-                count: batch.length,
-                lastSyncId: result.lastSyncId,
-            });
-            remaining.splice(0, remaining.length, ...nextRemaining);
-        }
-        catch (err) {
-            // If one request fails, hand it and every later request back to the
-            // normal lane. Their envelopes stay attached for safe retry.
-            const networkUnavailable = !ctx.runtime.onlineStatus.isOnline();
-            const isNetworkError = err instanceof Error &&
-                (err.message.includes('Failed to fetch') ||
-                    err.message.includes('Network request failed') ||
-                    err.message.includes('NetworkError'));
-            if (!networkUnavailable || !isNetworkError) {
-                ctx.runtime.observability.breadcrumb('Batch flush fallback failed', 'sync.transaction', 'warning', {
-                    error: err instanceof Error ? err.message : String(err),
-                });
-            }
-            for (const tx of [...batch, ...nextRemaining]) {
-                ctx.enqueue(tx);
-            }
-            return;
-        }
-    }
-}