@abloatai/ablo 0.25.0 → 0.26.0

package/dist/stores/SyncActionStore.js

@@ -4,6 +4,36 @@
  * Stores and manages sync actions received from the server.
  * Critical for delta sync and maintaining sync state consistency.
  */
+// Uses native IndexedDB for maximum performance
+import { z } from 'zod';
+import { getContext } from '../context.js';
+/**
+ * Zod boundary for rows read back from the sync-action store (T1.8): they
+ * were written by a previous session, so their shape is not guaranteed by
+ * this build. Default (strip) mode drops the storage bookkeeping fields
+ * (`storedAt`/`applied`/`appliedAt`) that used to be peeled off with an
+ * untyped rest-spread. Rows that don't parse are dropped + logged instead
+ * of being replayed as malformed deltas.
+ */
+const storedSyncActionSchema = z.object({
+    id: z.number(),
+    modelName: z.string(),
+    modelId: z.string(),
+    action: z.enum(['I', 'U', 'A', 'D', 'C', 'G', 'S', 'V']),
+    data: z.unknown(),
+    __class: z.literal('SyncAction').default('SyncAction'),
+});
+/** Parse one stored row into a SyncAction, or `null` (dropped + logged). */
+function toSyncAction(row) {
+    const parsed = storedSyncActionSchema.safeParse(row);
+    if (!parsed.success) {
+        getContext().logger.debug('[SyncActionStore] Dropping malformed stored sync action', {
+            issues: parsed.error.issues.map((i) => i.path.join('.')).join(', '),
+        });
+        return null;
+    }
+    return parsed.data;
+}
 /**
  * SyncActionStore - Manages sync actions (deltas)
  *
@@ -51,8 +81,8 @@ export class SyncActionStore {
                 }
                 resolve();
             };
-            tx.onerror = () => reject(tx.error);
-            request.onerror = () => reject(request.error);
+            tx.onerror = () => { reject(tx.error); };
+            request.onerror = () => { reject(request.error); };
         });
     }
     /**
@@ -83,10 +113,10 @@ export class SyncActionStore {
                         }
                     }
                 };
-                request.onerror = () => reject(request.error);
+                request.onerror = () => { reject(request.error); };
             }
-            tx.oncomplete = () => resolve();
-            tx.onerror = () => reject(tx.error);
+            tx.oncomplete = () => { resolve(); };
+            tx.onerror = () => { reject(tx.error); };
         });
     }
     /**
@@ -103,10 +133,9 @@ export class SyncActionStore {
                     resolve(undefined);
                     return;
                 }
-                const { storedAt, applied, ...action } = data;
-                resolve(action);
+                resolve(toSyncAction(data) ?? undefined);
             };
-            request.onerror = () => reject(request.error);
+            request.onerror = () => { reject(request.error); };
         });
     }
     /**
@@ -121,10 +150,12 @@ export class SyncActionStore {
             const request = index.getAll(range);
             request.onsuccess = () => {
                 const allData = request.result;
-                const actions = allData.map(({ storedAt, applied, ...action }) => action);
+                const actions = allData
+                    .map(toSyncAction)
+                    .filter((action) => action !== null);
                 resolve(actions);
             };
-            request.onerror = () => reject(request.error);
+            request.onerror = () => { reject(request.error); };
         });
     }
     /**
@@ -142,7 +173,9 @@ export class SyncActionStore {
      * Mark sync action as applied
      */
     async markAsApplied(syncId) {
-        return new Promise(async (resolve, reject) => {
+        // Plain (non-async) executor: a sync throw (e.g. transaction() on a
+        // closing DB) must reject this promise, not vanish into an ignored one.
+        return new Promise((resolve, reject) => {
             const tx = this.db.transaction([this.storeName], 'readwrite');
             const store = tx.objectStore(this.storeName);
             const getRequest = store.get(syncId);
@@ -152,10 +185,10 @@ export class SyncActionStore {
                     existing.applied = true;
                     existing.appliedAt = Date.now();
                     const putRequest = store.put(existing);
-                    putRequest.onerror = () => reject(putRequest.error);
+                    putRequest.onerror = () => { reject(putRequest.error); };
                 }
             };
-            getRequest.onerror = () => reject(getRequest.error);
+            getRequest.onerror = () => { reject(getRequest.error); };
             tx.oncomplete = async () => {
                 // Update tracking
                 if (syncId > this.lastAppliedSyncId) {
@@ -172,7 +205,7 @@ export class SyncActionStore {
                     reject(error);
                 }
             };
-            tx.onerror = () => reject(tx.error);
+            tx.onerror = () => { reject(tx.error); };
         });
     }
     /**
@@ -181,7 +214,7 @@ export class SyncActionStore {
     async markManyAsApplied(syncIds) {
         if (syncIds.length === 0)
             return;
-        return new Promise(async (resolve, reject) => {
+        return new Promise((resolve, reject) => {
             const tx = this.db.transaction([this.storeName], 'readwrite');
             const store = tx.objectStore(this.storeName);
             let processed = 0;
@@ -206,14 +239,14 @@ export class SyncActionStore {
                                 }
                             }
                         };
-                        putRequest.onerror = () => reject(putRequest.error);
+                        putRequest.onerror = () => { reject(putRequest.error); };
                     }
                     else {
                         processed++;
                         this.pendingActions.delete(syncId);
                     }
                 };
-                getRequest.onerror = () => reject(getRequest.error);
+                getRequest.onerror = () => { reject(getRequest.error); };
             }
             tx.oncomplete = async () => {
                 // Update metadata with the highest sync ID
@@ -231,7 +264,7 @@ export class SyncActionStore {
                     resolve();
                 }
             };
-            tx.onerror = () => reject(tx.error);
+            tx.onerror = () => { reject(tx.error); };
         });
     }
     /**
@@ -265,7 +298,7 @@ export class SyncActionStore {
                     currentId++;
                     checkNext();
                 };
-                request.onerror = () => reject(request.error);
+                request.onerror = () => { reject(request.error); };
             };
             checkNext();
         });
@@ -293,7 +326,7 @@ export class SyncActionStore {
                     currentId++;
                     checkNext();
                 };
-                request.onerror = () => reject(request.error);
+                request.onerror = () => { reject(request.error); };
             };
             checkNext();
         });
@@ -317,7 +350,7 @@ export class SyncActionStore {
                             cleaned++;
                             cursor.continue();
                         };
-                        deleteRequest.onerror = () => reject(deleteRequest.error);
+                        deleteRequest.onerror = () => { reject(deleteRequest.error); };
                     }
                     else {
                         cursor.continue();
@@ -328,7 +361,7 @@ export class SyncActionStore {
                     resolve(cleaned);
                 }
             };
-            request.onerror = () => reject(request.error);
+            request.onerror = () => { reject(request.error); };
         });
     }
     /**
@@ -344,8 +377,8 @@ export class SyncActionStore {
                 this.lastAppliedSyncId = 0;
                 resolve();
             };
-            tx.onerror = () => reject(tx.error);
-            request.onerror = () => reject(request.error);
+            tx.onerror = () => { reject(tx.error); };
+            request.onerror = () => { reject(request.error); };
         });
     }
     /**
@@ -373,7 +406,7 @@ export class SyncActionStore {
                     newestAction: timestamps.length > 0 ? new Date(timestamps[timestamps.length - 1]) : null,
                 });
             };
-            request.onerror = () => reject(request.error);
+            request.onerror = () => { reject(request.error); };
         });
     }
     /**
@@ -389,11 +422,11 @@ export class SyncActionStore {
                 metadata.lastSyncId = syncId;
                 metadata.updatedAt = new Date();
                 const putRequest = store.put(metadata, 'metadata');
-                putRequest.onerror = () => reject(putRequest.error);
+                putRequest.onerror = () => { reject(putRequest.error); };
             };
-            getRequest.onerror = () => reject(getRequest.error);
-            tx.oncomplete = () => resolve();
-            tx.onerror = () => reject(tx.error);
+            getRequest.onerror = () => { reject(getRequest.error); };
+            tx.oncomplete = () => { resolve(); };
+            tx.onerror = () => { reject(tx.error); };
         });
     }
     /**
@@ -416,14 +449,14 @@ export class SyncActionStore {
                     resolve(undefined);
                 }
             };
-            request.onerror = () => reject(request.error);
+            request.onerror = () => { reject(request.error); };
         });
     }
     /**
      * Rewind to a specific sync ID (for conflict resolution)
      */
     async rewindTo(syncId) {
-        return new Promise(async (resolve, reject) => {
+        return new Promise((resolve, reject) => {
             // Get all actions after this sync ID
             const tx = this.db.transaction([this.storeName], 'readonly');
             const store = tx.objectStore(this.storeName);
@@ -461,21 +494,23 @@ export class SyncActionStore {
                             this.lastAppliedSyncId = syncId - 1;
                         }
                     };
-                    putRequest.onerror = () => reject(putRequest.error);
+                    putRequest.onerror = () => { reject(putRequest.error); };
                 }
                 writeTx.oncomplete = async () => {
                     try {
                         await this.updateLastSyncId(this.lastAppliedSyncId);
-                        const result = actionsToRewind.map(({ storedAt, applied, ...action }) => action);
+                        const result = actionsToRewind
+                            .map(toSyncAction)
+                            .filter((action) => action !== null);
                         resolve(result);
                     }
                     catch (error) {
                         reject(error);
                     }
                 };
-                writeTx.onerror = () => reject(writeTx.error);
+                writeTx.onerror = () => { reject(writeTx.error); };
             };
-            request.onerror = () => reject(request.error);
+            request.onerror = () => { reject(request.error); };
         });
     }
 }

package/dist/surface.d.ts

@@ -23,7 +23,7 @@ export declare const PUBLIC_MODEL_VERBS: readonly ["retrieve", "list", "get", "g
 export declare const PUBLIC_LIST_OPTION_KEYS: readonly ["where", "filter", "orderBy", "limit", "offset", "state"];
 /** Public keys of `AbloOptions`. `schema` is required; the rest are optional
  *  (the locked happy path is `Ablo({ schema, apiKey, databaseUrl, transport })`). */
-export declare const PUBLIC_ABLO_OPTION_KEYS: readonly ["schema", "apiKey", "databaseUrl", "persistence", "transport", "debug", "logLevel", "authToken", "baseURL", "fetch", "defaultHeaders", "defaultQuery", "dangerouslyAllowBrowser"];
+export declare const PUBLIC_ABLO_OPTION_KEYS: readonly ["schema", "apiKey", "authEndpoint", "databaseUrl", "persistence", "transport", "debug", "logLevel", "authToken", "baseURL", "fetch", "defaultHeaders", "defaultQuery", "dangerouslyAllowBrowser"];
 export type ModelVerb = (typeof PUBLIC_MODEL_VERBS)[number];
 export type ListOptionKey = (typeof PUBLIC_LIST_OPTION_KEYS)[number];
 export type AbloOptionKey = (typeof PUBLIC_ABLO_OPTION_KEYS)[number];

package/dist/surface.js

@@ -48,6 +48,7 @@ export const PUBLIC_LIST_OPTION_KEYS = [
 export const PUBLIC_ABLO_OPTION_KEYS = [
     'schema',
     'apiKey',
+    'authEndpoint',
     'databaseUrl',
     'persistence',
     'transport',

package/dist/sync/AreaOfInterestManager.d.ts

@@ -41,7 +41,7 @@ export interface SubscriptionTransport {
      * Resolves with the server's effective set (which the manager treats as
      * authoritative for its next diff).
      */
-    updateSubscription(syncGroups: ReadonlyArray<string>): Promise<{
+    updateSubscription(syncGroups: readonly string[]): Promise<{
         syncGroups: string[];
     }>;
 }
@@ -52,7 +52,7 @@ export interface AreaOfInterestOptions {
      * Groups always present in the effective set (e.g. `org:<id>`,
      * `user:<id>`). Never warm, never expired.
      */
-    baseGroups?: ReadonlyArray<string>;
+    baseGroups?: readonly string[];
     /**
      * How long a `leave`-ed group stays subscribed before it actually drops.
      * This is the hysteresis margin. Default 30s.

package/dist/sync/AreaOfInterestManager.js

@@ -71,7 +71,7 @@ export class AreaOfInterestManager {
             const schedule = options.scheduler ??
                 ((fn, ms) => {
                     const handle = setInterval(fn, ms);
-                    return () => clearInterval(handle);
+                    return () => { clearInterval(handle); };
                 });
             this.cancelSweep = schedule(() => {
                 void this.sweep();

package/dist/sync/BootstrapHelper.d.ts

@@ -10,9 +10,7 @@ export interface BootstrapData {
      * boundary — the per-model shape is asserted by the consumer (sync
      * engine reduce + IDB write) using the registered schema.
      */
-    models?: {
-        [typename: string]: unknown[];
-    };
+    models?: Record<string, unknown[]>;
     deltas?: ValidatedServerDelta[];
     deltaCount?: number;
     /** Model types whose server-side query failed (timeout, RLS error, etc.) */

package/dist/sync/BootstrapHelper.js

@@ -176,7 +176,7 @@ export class BootstrapHelper {
                 // Also do NOT fallback to cache - the user must sign in again
                 if (SyncSessionError.isSessionError(error)) {
                     getContext().observability.breadcrumb('Bootstrap session error - redirecting to sign-in', 'sync.bootstrap', 'warning', {
-                        statusCode: error.statusCode,
+                        statusCode: (error).statusCode,
                     });
                     throw error;
                 }
@@ -226,7 +226,7 @@ export class BootstrapHelper {
         // client-side was historical: it predated the auth-context pipeline
         // and forced a cross-org guard to defend against the SDK lying.
         const params = new URLSearchParams();
-        this.options.syncGroups.forEach((g) => params.append('syncGroups', g));
+        this.options.syncGroups.forEach((g) => { params.append('syncGroups', g); });
         if (this.options.instantModels && this.options.instantModels.length > 0) {
             params.append('models', this.options.instantModels.join(','));
         }
@@ -369,12 +369,33 @@ export class BootstrapHelper {
      */
     async fetchEntity(modelName, id) {
         const url = `${this.options.baseUrl}/sync/entity/${modelName}/${id}`;
-        const response = await fetch(url, {
-            method: 'GET',
-            headers: withAuthHeaders(this.options.getAuthToken, {
-                'Content-Type': 'application/json',
-            }, this.options.authToken),
-        });
+        // Same `fetchTimeout` deadline `performFetch` uses — this was the one
+        // fetch in this file with no AbortSignal, so a hung self-heal read could
+        // stall its caller forever. A LOCAL controller (not `this.abortController`)
+        // so an entity self-heal never cancels a concurrent bootstrap fetch.
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => { controller.abort(); }, this.options.fetchTimeout);
+        let response;
+        try {
+            response = await fetch(url, {
+                method: 'GET',
+                headers: withAuthHeaders(this.options.getAuthToken, {
+                    'Content-Type': 'application/json',
+                }, this.options.authToken),
+                signal: controller.signal,
+            });
+        }
+        catch (error) {
+            // Convert abort to the existing typed timeout error (same code as the
+            // bootstrap fetch path) so callers get a retryable connection error.
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw new AbloConnectionError(`Entity fetch timed out after ${this.options.fetchTimeout}ms`, { code: 'bootstrap_fetch_timeout', cause: error });
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
         if (response.status === 404) {
             return null;
         }

package/dist/sync/ConnectionManager.d.ts

@@ -167,6 +167,14 @@ export declare class ConnectionManager {
     send(event: ConnectionEvent): void;
     private transition;
     private onEnterState;
+    /**
+     * FSM effects are fire-and-forget by design (`onEnterState` is sync). Each
+     * effect catches its own operational failures and maps them onto an FSM
+     * event, so a rejection here means the machine wedged mid-transition
+     * (`send()` or a transition listener threw) with no retry timer armed past
+     * it — capture it instead of losing the reconnect loop silently.
+     */
+    private captureEffectFailure;
     private runProbe;
     /**
      * Re-mint the short-lived access key on `refreshing_credential`. Delegates to

package/dist/sync/ConnectionManager.js

@@ -349,16 +349,16 @@ export class ConnectionManager {
                 if (event.type === 'WS_DISCONNECTED') {
                     this.callbacks?.onDisconnectWebSocket();
                 }
-                this.runProbe();
+                void this.runProbe().catch(this.captureEffectFailure('probe'));
                 break;
             case 'waiting_for_network':
                 this.scheduleBackoff();
                 break;
             case 'reconnecting':
-                this.runReconnect();
+                void this.runReconnect().catch(this.captureEffectFailure('reconnect'));
                 break;
             case 'refreshing_credential':
-                this.runRefreshCredential();
+                void this.runRefreshCredential().catch(this.captureEffectFailure('refresh-credential'));
                 break;
             case 'backoff':
                 this.scheduleBackoff();
@@ -382,6 +382,21 @@ export class ConnectionManager {
         }
     }
     // ── Async operations ─────────────────────────────────────────────────
+    /**
+     * FSM effects are fire-and-forget by design (`onEnterState` is sync). Each
+     * effect catches its own operational failures and maps them onto an FSM
+     * event, so a rejection here means the machine wedged mid-transition
+     * (`send()` or a transition listener threw) with no retry timer armed past
+     * it — capture it instead of losing the reconnect loop silently.
+     */
+    captureEffectFailure(effect) {
+        return (error) => {
+            getContext().observability.captureWebSocketError({
+                context: `connection-fsm-${effect}`,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        };
+    }
     async runProbe() {
         try {
             const result = await probeNetwork({
@@ -609,7 +624,7 @@ export class ConnectionManager {
                 // means definitely offline"), and reloading while truly offline
                 // would either serve cached content forever or fail and leave
                 // the user with a broken page.
-                const browserOnline = typeof navigator === 'undefined' || navigator.onLine === true;
+                const browserOnline = typeof navigator === 'undefined' || navigator.onLine;
                 if (this.stuckCycles >= MAX_STUCK_CYCLES_BEFORE_RELOAD && browserOnline) {
                     getContext().logger.debug('[ConnectionManager] Watchdog: sustained stuck — hard reload');
                     getContext().observability.breadcrumb('Watchdog hard reload', 'sync.offline', 'error');

package/dist/sync/HydrationCoordinator.d.ts

@@ -23,6 +23,7 @@ import type { ObjectPool } from '../ObjectPool.js';
 import type { Database } from '../Database.js';
 import type { Model } from '../Model.js';
 import type { ModelRegistry } from '../ModelRegistry.js';
+import type { RecoveryClass } from '../errorCodes.js';
 import type { LoadWhere, WhereClause } from '../query/types.js';
 import type { Schema } from '../schema/schema.js';
 export interface HydrationCoordinatorOptions {
@@ -94,6 +95,15 @@ export declare class HydrationCoordinator {
      */
     private readonly hydratedKeys;
     private authTokenProvider;
+    /**
+     * The auth-recovery backbone (the store's `recoverFromAuthRejection`),
+     * late-bound like {@link setAuthTokenProvider} because the store doesn't
+     * exist yet when the coordinator is constructed. Handed to `postQuery` so a
+     * 401 on the lazy lane re-mints through the SAME single-flight path the WS
+     * probe and proactive pre-roll use, then replays once — instead of silently
+     * returning empty rows against an expired key forever.
+     */
+    private credentialRecovery;
     constructor(opts: HydrationCoordinatorOptions);
     /**
      * Late-bind the auth token getter. Browser cookie consumers can omit this;
@@ -101,6 +111,8 @@ export declare class HydrationCoordinator {
      * bootstrap and the WebSocket.
      */
     setAuthTokenProvider(provider: () => string | null): void;
+    /** Late-bind the auth-recovery backbone. See {@link credentialRecovery}. */
+    setCredentialRecovery(recover: (recovery: RecoveryClass) => Promise<'retry' | 'stop'>): void;
     /** @deprecated Use `setAuthTokenProvider`. */
     setCapabilityTokenProvider(provider: () => string | null): void;
     /**

package/dist/sync/HydrationCoordinator.js

@@ -45,6 +45,15 @@ export class HydrationCoordinator {
      */
     hydratedKeys = new Set();
     authTokenProvider = null;
+    /**
+     * The auth-recovery backbone (the store's `recoverFromAuthRejection`),
+     * late-bound like {@link setAuthTokenProvider} because the store doesn't
+     * exist yet when the coordinator is constructed. Handed to `postQuery` so a
+     * 401 on the lazy lane re-mints through the SAME single-flight path the WS
+     * probe and proactive pre-roll use, then replays once — instead of silently
+     * returning empty rows against an expired key forever.
+     */
+    credentialRecovery = null;
     constructor(opts) {
         this.opts = opts;
         this.authTokenProvider = opts.getAuthToken ?? opts.getCapabilityToken ?? null;
@@ -57,6 +66,10 @@ export class HydrationCoordinator {
     setAuthTokenProvider(provider) {
         this.authTokenProvider = provider;
     }
+    /** Late-bind the auth-recovery backbone. See {@link credentialRecovery}. */
+    setCredentialRecovery(recover) {
+        this.credentialRecovery = recover;
+    }
     /** @deprecated Use `setAuthTokenProvider`. */
     setCapabilityTokenProvider(provider) {
         this.setAuthTokenProvider(provider);
@@ -82,9 +95,15 @@ export class HydrationCoordinator {
             return inFlight;
         const work = this.runFetch(modelName, typename, ModelClass, clauses, options, queryKey);
         this.inFlight.set(queryKey, work);
-        work.finally(() => {
+        // The rejection (if any) reaches callers via the returned `work`; this
+        // side-chain only clears the single-flight slot. Without the trailing
+        // catch, `.finally()` mirrors the rejection into a second, unhandled
+        // promise even when every caller handles theirs.
+        void work
+            .finally(() => {
             this.inFlight.delete(queryKey);
-        });
+        })
+            .catch(() => undefined);
         return work;
     }
     async runFetch(modelName, typename, ModelClass, clauses, options, queryKey) {
@@ -282,7 +301,7 @@ export class HydrationCoordinator {
             if (!Array.isArray(all))
                 return [];
             const idSet = new Set(parentIds);
-            return all.filter((r) => idSet.has(r[foreignKey]));
+            return all.filter((r) => idSet.has((r)[foreignKey]));
         }
         catch {
             return [];
@@ -368,6 +387,7 @@ export class HydrationCoordinator {
         const result = await postQuery({
             baseUrl: this.opts.baseUrl,
             getAuthToken: this.authTokenProvider ?? undefined,
+            recoverCredential: this.credentialRecovery ?? undefined,
         }, { queries: [query] });
         const rows = Array.isArray(result.results[0]) ? result.results[0] : [];
         // Normalize: wire rows lack `__typename` when the server elides it.
@@ -523,8 +543,8 @@ async function scanIdb(database, modelName, clauses) {
     // through to full-scan + filter.
     if (clausesAreAllEquality(clauses)) {
         const indexedKeys = Object.keys(eqClauses).filter((k) => k !== 'id' && typeof eqClauses[k] === 'string');
-        if (indexedKeys.length === 1) {
-            const idxKey = indexedKeys[0];
+        const idxKey = indexedKeys.length === 1 ? indexedKeys[0] : undefined;
+        if (idxKey !== undefined) {
             try {
                 const rows = await store.getAllFromIndex(idxKey, eqClauses[idxKey]);
                 if (Array.isArray(rows)) {

package/dist/sync/NetworkProbe.d.ts

@@ -59,8 +59,9 @@ export declare const probeResultSchema: z.ZodObject<{
 export type ProbeResult = z.infer<typeof probeResultSchema>;
 export interface NetworkProbeOptions {
     /**
-     * Sync-server base URL (HTTP or WS scheme accepted). If omitted, falls
-     * back to the legacy `NEXT_PUBLIC_GO_SERVER_URL` default.
+     * Sync-server base URL (HTTP or WS scheme accepted). If omitted, the probe
+     * targets the canonical hosted endpoint ({@link ABLO_DEFAULT_BASE_URL}) —
+     * the same default `Ablo()` resolves.
      */
     baseUrl?: string;
     /**

package/dist/sync/NetworkProbe.js

@@ -28,6 +28,7 @@ import { z } from 'zod';
 import { getContext } from '../context.js';
 import { classifyRecovery } from '../errors.js';
 import { withAuthHeaders } from '../auth/credentialSource.js';
+import { ABLO_DEFAULT_BASE_URL } from '../client/hostedEndpoints.js';
 /**
  * The closed set of probe outcomes — one value carrying both reachability and
  * credential disposition, so the {@link ConnectionManager} branches on a single
@@ -64,11 +65,11 @@ const PROBE_TIMEOUT_MS = 4000;
  * normalisation in `BootstrapHelper` / `createSyncEngine`.
  */
 function resolveProbeUrl(baseUrl) {
-    // Fall back to the legacy env var so callers that haven't been migrated
-    // to pass an explicit baseUrl keep working.
-    const resolved = baseUrl ??
-        (typeof process !== 'undefined' ? process.env?.NEXT_PUBLIC_GO_SERVER_URL : undefined) ??
-        'http://localhost:8080';
+    // No explicit baseUrl → probe the canonical hosted endpoint, matching the
+    // `Ablo()` default. (This used to fall back to the REMOVED Go engine's
+    // `NEXT_PUBLIC_GO_SERVER_URL` and then `http://localhost:8080`, so a probe
+    // without a baseUrl reported a healthy production deployment as offline.)
+    const resolved = baseUrl ?? ABLO_DEFAULT_BASE_URL;
     // Normalize ws → http so fetch() accepts the URL. Strip any trailing slash
     // so we don't produce `//api/auth/check`.
     const httpBase = resolved.replace(/^ws/, 'http').replace(/\/+$/, '');
@@ -98,7 +99,7 @@ export async function probeNetwork(input) {
         return { outcome: 'unreachable', latencyMs: null };
     }
     const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
+    const timeout = setTimeout(() => { controller.abort(); }, PROBE_TIMEOUT_MS);
     const start = performance.now();
     try {
         const headers = withAuthHeaders(getAuthToken, { 'Cache-Control': 'no-cache' }, authToken);