@abloatai/humans 0.37.0

package/dist/local/sync/participants.js

@@ -0,0 +1,342 @@
+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/sync/persistedPrefix.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Returns the highest sync id in the durable prefix of an ordered delta frame.
+ *
+ * A frame may span several IndexedDB stores, each committed in its own
+ * transaction. Those transactions can succeed and fail independently. The
+ * resume cursor may advance only through the first failed input: taking the
+ * maximum id from any successful store would skip an earlier failed delta on
+ * every later catch-up.
+ */
+export declare function highestPersistedPrefixSyncId(deltas: readonly {
+    readonly syncId?: number | string;
+}[], persistedIndexes: ReadonlySet<number>): number;

package/dist/local/sync/persistedPrefix.js

@@ -0,0 +1,22 @@
+/**
+ * Returns the highest sync id in the durable prefix of an ordered delta frame.
+ *
+ * A frame may span several IndexedDB stores, each committed in its own
+ * transaction. Those transactions can succeed and fail independently. The
+ * resume cursor may advance only through the first failed input: taking the
+ * maximum id from any successful store would skip an earlier failed delta on
+ * every later catch-up.
+ */
+export function highestPersistedPrefixSyncId(deltas, persistedIndexes) {
+    let through = 0;
+    for (let index = 0; index < deltas.length; index += 1) {
+        if (!persistedIndexes.has(index))
+            break;
+        const raw = deltas[index]?.syncId;
+        const syncId = typeof raw === 'string' ? Number(raw) : raw;
+        if (typeof syncId === 'number' && Number.isFinite(syncId) && syncId > through) {
+            through = syncId;
+        }
+    }
+    return through;
+}

package/dist/local/sync/reconnect.d.ts

@@ -0,0 +1,23 @@
+import type { RuntimeContext } from '../RuntimeContext.js';
+import type { SyncClient } from '../SyncClient.js';
+import type { Database } from '../Database.js';
+import type { InstanceCache } from '../InstanceCache.js';
+import type { SyncWebSocket } from './SyncWebSocket.js';
+import type { DefaultCollaborationEvents, EventMap } from './SyncWebSocket.js';
+import type { SyncStatus } from '../storeContract.js';
+import type { UserContext } from '../BaseSyncedStore.js';
+import type { BootstrapResult } from '../Database.js';
+export interface ReconnectHost<TCollaboration extends EventMap<TCollaboration> = DefaultCollaborationEvents> {
+    userContext: UserContext | null;
+    database: Database;
+    syncClient: SyncClient;
+    objectPool: InstanceCache;
+    syncWebSocket: SyncWebSocket<TCollaboration>;
+    runtime: RuntimeContext;
+    dataReady: boolean;
+    checkSyncGroupShrinkage(): Promise<void>;
+    resolveSyncGroups(context: UserContext): readonly string[];
+    applyBootstrapToPool(result: BootstrapResult): void;
+    updateSyncStatus(updates: Partial<SyncStatus>): void;
+}
+export declare function performReconnect<TCollaboration extends EventMap<TCollaboration>>(host: ReconnectHost<TCollaboration>): Promise<'success' | 'session_error' | 'network_error'>;

package/dist/local/sync/reconnect.js

@@ -0,0 +1,55 @@
+import { AbloSessionError } from '@abloatai/transaction/errors';
+export async function performReconnect(host) {
+    if (!host.userContext)
+        return 'network_error';
+    try {
+        await host.checkSyncGroupShrinkage();
+        const requirements = await host.database.requiredBootstrap();
+        if (requirements.type === 'full' || requirements.lastSyncId === 0) {
+            host.updateSyncStatus({ state: 'syncing', progress: 0 });
+            const result = await host.database.bootstrapFromServer(requirements, host.resolveSyncGroups(host.userContext));
+            host.applyBootstrapToPool(result);
+            host.dataReady = true;
+        }
+        else if (!host.dataReady) {
+            await host.syncClient.hydrateFromDatabase();
+            host.dataReady = true;
+        }
+        if (!host.syncWebSocket.isConnected()) {
+            host.syncWebSocket.resetReconnectAttempts();
+            host.syncWebSocket.connect();
+        }
+        host.updateSyncStatus({ state: 'idle', progress: 100 });
+        return 'success';
+    }
+    catch (error) {
+        host.runtime.observability.captureBootstrapFailure(error, {
+            type: 'connection-store-reconnect',
+        });
+        if (AbloSessionError.isSessionError(error)) {
+            host.syncWebSocket.setSessionErrorDetected();
+            host.syncWebSocket.disconnect();
+            host.updateSyncStatus({ state: 'error', error });
+            host.database.clear({ includeWriteJournal: true }).catch(() => undefined);
+            host.objectPool.clear();
+            return 'session_error';
+        }
+        if (!host.dataReady && host.objectPool.size === 0) {
+            try {
+                await host.syncClient.hydrateFromDatabase();
+                if (host.objectPool.size > 0) {
+                    host.dataReady = true;
+                    host.runtime.logger.info('[BaseSyncedStore] Hydrated from local fallback', {
+                        objectPoolSize: host.objectPool.size,
+                    });
+                }
+            }
+            catch (fallbackError) {
+                host.runtime.logger.debug('[BaseSyncedStore] Local fallback failed', {
+                    error: fallbackError instanceof Error ? fallbackError.message : String(fallbackError),
+                });
+            }
+        }
+        return 'network_error';
+    }
+}

package/dist/local/sync/schemaDrift.d.ts

@@ -0,0 +1,55 @@
+/**
+ * The semantic schema-drift classifier — the question that matters is not
+ * "did the schema change at all?" (one whole-schema hash answers that, and
+ * welds every client to every push) but "does THIS client use anything that
+ * changed?". This module compares only the models the client declares against
+ * the server's per-model surface (`GET /api/schema`), so:
+ *
+ *   - a purely additive server change (models this build never references) is
+ *     SILENCE — deployed clients don't care what they don't use;
+ *   - a model this build declares that the server doesn't have is named, with
+ *     the push as the fix;
+ *   - a shared model whose content differs is named, so "which field moved"
+ *     is one `ablo status` away instead of a hash-guessing game.
+ *
+ * Pure and transport-free; the BootstrapFetcher owns fetching the surface.
+ */
+/** One model as the server's schema read-back reports it. */
+export interface ServerSchemaModel {
+    readonly key: string;
+    /** Per-model content hash; absent on servers older than this check. */
+    readonly hash?: string;
+}
+export type SchemaDriftFinding = 
+/** Every model this client declares exists server-side with matching content
+ *  (the server may know more — that's an additive lead, not drift). */
+{
+    readonly kind: 'aligned';
+}
+/** Models this build declares that the server has no idea about — writes to
+ *  them will be declined until the schema is pushed. */
+ | {
+    readonly kind: 'unpushed';
+    readonly models: readonly string[];
+}
+/** Shared models whose content differs between this build and the server
+ *  (may also carry unpushed models found alongside). */
+ | {
+    readonly kind: 'changed';
+    readonly models: readonly string[];
+    readonly unpushed: readonly string[];
+}
+/** The server surface carries no per-model hashes (older server) — the
+ *  caller falls back to the whole-hash comparison. */
+ | {
+    readonly kind: 'unknown';
+};
+export declare function classifySchemaDrift(clientModels: Readonly<Record<string, string>>, serverModels: readonly ServerSchemaModel[]): SchemaDriftFinding;
+/**
+ * The warning for a real, named divergence. Calm and specific: which models,
+ * what that means for this client, and the one next step. Never speaks about
+ * hashes — the point of the semantic check is that nobody has to compare hex.
+ */
+export declare function describeSchemaDrift(finding: Extract<SchemaDriftFinding, {
+    kind: 'unpushed' | 'changed';
+}>, serverLabel: string): string;

package/dist/local/sync/schemaDrift.js

@@ -0,0 +1,53 @@
+/**
+ * The semantic schema-drift classifier — the question that matters is not
+ * "did the schema change at all?" (one whole-schema hash answers that, and
+ * welds every client to every push) but "does THIS client use anything that
+ * changed?". This module compares only the models the client declares against
+ * the server's per-model surface (`GET /api/schema`), so:
+ *
+ *   - a purely additive server change (models this build never references) is
+ *     SILENCE — deployed clients don't care what they don't use;
+ *   - a model this build declares that the server doesn't have is named, with
+ *     the push as the fix;
+ *   - a shared model whose content differs is named, so "which field moved"
+ *     is one `ablo status` away instead of a hash-guessing game.
+ *
+ * Pure and transport-free; the BootstrapFetcher owns fetching the surface.
+ */
+export function classifySchemaDrift(clientModels, serverModels) {
+    if (serverModels.length > 0 && serverModels.every((m) => !m.hash)) {
+        return { kind: 'unknown' };
+    }
+    const server = new Map(serverModels.map((m) => [m.key, m.hash]));
+    const unpushed = [];
+    const changed = [];
+    for (const [key, hash] of Object.entries(clientModels)) {
+        const serverHash = server.get(key);
+        if (serverHash === undefined)
+            unpushed.push(key);
+        else if (serverHash !== hash)
+            changed.push(key);
+    }
+    if (changed.length > 0)
+        return { kind: 'changed', models: changed, unpushed };
+    if (unpushed.length > 0)
+        return { kind: 'unpushed', models: unpushed };
+    return { kind: 'aligned' };
+}
+/**
+ * The warning for a real, named divergence. Calm and specific: which models,
+ * what that means for this client, and the one next step. Never speaks about
+ * hashes — the point of the semantic check is that nobody has to compare hex.
+ */
+export function describeSchemaDrift(finding, serverLabel) {
+    if (finding.kind === 'unpushed') {
+        return (`Ablo: This build declares models the server at ${serverLabel} doesn't have yet ` +
+            `(${finding.models.join(', ')}). Writes to them will be declined until the schema is ` +
+            `pushed — run \`ablo push\` (and \`ablo status\` to confirm it targets this server).`);
+    }
+    const alsoUnpushed = finding.unpushed.length > 0 ? ` (${finding.unpushed.join(', ')} not pushed yet)` : '';
+    return (`Ablo: These models differ between this build and the server at ${serverLabel}: ` +
+        `${finding.models.join(', ')}${alsoUnpushed}. Reads and writes touching what changed may be ` +
+        `declined — \`ablo status\` shows the deployed shape; pushing your schema or deploying a ` +
+        `current build aligns them.`);
+}

package/dist/local/sync/schemas.d.ts

@@ -0,0 +1,71 @@
+/**
+ * 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;