@luckystack/core 0.1.0

package/dist/client.js

@@ -0,0 +1,1344 @@
+// src/projectConfig.ts
+var DEFAULT_PROJECT_CONFIG = {
+  app: {
+    publicUrl: ""
+  },
+  logging: {
+    devLogs: false,
+    devNotifications: false,
+    socketStatus: false,
+    socketStartup: false,
+    stream: false
+  },
+  rateLimiting: {
+    enabled: true,
+    store: "memory",
+    redisKeyPrefix: "rate-limit",
+    defaultApiLimit: 60,
+    defaultIpLimit: 100,
+    windowMs: 6e4,
+    cleanupIntervalMs: 6e4
+  },
+  session: {
+    basedToken: false,
+    expiryDays: 7,
+    allowMultiple: false,
+    perBrowser: "single",
+    perUser: "single",
+    maxConcurrentPerUser: null,
+    onConflict: "revokeOld",
+    notifyOldDeviceOnRevoke: true,
+    //? Empty default — `getProjectName()` reads `process.env.PROJECT_NAME` at
+    //? call time and falls back to `'luckystack'`. Avoids capturing env at
+    //? module-load before dotenv runs.
+    projectName: ""
+  },
+  http: {
+    sessionCookieName: "token",
+    sessionCookieSameSite: "Strict",
+    sessionCookiePath: "/",
+    requestBodyMaxBytes: 1024 * 1024,
+    healthEndpoint: "/_health",
+    liveEndpoint: "/livez",
+    readyEndpoint: "/readyz",
+    testResetEndpoint: "/_test/reset",
+    stream: {
+      queryParam: "stream",
+      enabledValue: "true",
+      connectedComment: ": connected"
+    },
+    securityHeaders: {
+      frameOptions: "SAMEORIGIN",
+      referrerPolicy: "no-referrer",
+      xssProtection: "1; mode=block",
+      contentTypeOptions: "nosniff"
+    },
+    cors: {
+      allowedMethods: "GET, POST, PUT, DELETE, OPTIONS",
+      allowedHeaders: "Content-Type, Authorization, X-Session-Based-Token, X-CSRF-Token, X-Request-Id",
+      exposedHeaders: "X-Session-Token, X-Request-Id",
+      credentials: true,
+      allowedOrigins: [],
+      allowLocalhost: false
+    }
+  },
+  auth: {
+    oauthStateTtlSeconds: 60 * 10,
+    passwordMinLength: 8,
+    passwordMaxLength: 191,
+    passwordPolicy: {
+      minLength: 8,
+      maxLength: 191,
+      requireUppercase: false,
+      requireLowercase: false,
+      requireNumber: false,
+      requireSpecial: false,
+      forbidCommon: true
+    },
+    emailMaxLength: 191,
+    nameMaxLength: 191,
+    bcryptRounds: 10,
+    providerAccountStrategy: "per-provider",
+    forgotPassword: "disabled",
+    passwordResetTtlSeconds: 60 * 60,
+    emailChangeTtlSeconds: 60 * 60
+  },
+  socket: {
+    maxHttpBufferSize: 5 * 1024 * 1024,
+    pingTimeout: 2e4,
+    pingInterval: 25e3
+  },
+  sync: {
+    streamThrottle: {
+      flushAtChars: 32,
+      flushEveryMs: 50,
+      field: "chunk"
+    },
+    fanoutYieldEvery: 100,
+    fanoutYieldMs: 1
+  },
+  offlineQueue: {
+    maxSize: 200,
+    maxAgeMs: 60 * 60 * 1e3,
+    dropPolicy: "drop-oldest"
+  },
+  dev: {
+    hotReloadDebounceMs: 120,
+    watcherStabilityThresholdMs: 120,
+    watcherPollIntervalMs: 20
+  },
+  paths: {
+    srcDir: "src",
+    serverDir: "server",
+    sharedDir: "shared",
+    uploadsDir: "uploads",
+    publicDir: "public",
+    serverFunctionsDir: "server/functions",
+    serverFunctionDirs: ["functions", "shared"],
+    generatedSocketTypes: "src/_sockets/apiTypes.generated.ts",
+    generatedApiSchemas: "src/_sockets/apiInputSchemas.generated.ts",
+    generatedApiDocs: "src/docs/apiDocs.generated.json"
+  },
+  defaultLanguage: "en",
+  defaultTheme: "light",
+  socketActivityBroadcaster: false,
+  socketStatusIndicator: false,
+  locationProviderEnabled: false,
+  loginRedirectUrl: "/"
+};
+var isPlainObject = (value) => {
+  if (value === null || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+};
+var deepMerge = (base, override) => {
+  if (override === void 0) return base;
+  if (!isPlainObject(base) || !isPlainObject(override)) {
+    return override ?? base;
+  }
+  const result = { ...base };
+  for (const [key, overrideValue] of Object.entries(override)) {
+    if (overrideValue === void 0) continue;
+    const baseValue = base[key];
+    result[key] = isPlainObject(baseValue) && isPlainObject(overrideValue) ? deepMerge(baseValue, overrideValue) : overrideValue;
+  }
+  return result;
+};
+var activeConfig = DEFAULT_PROJECT_CONFIG;
+var isRegistered = false;
+var registerProjectConfig = (config) => {
+  activeConfig = deepMerge(DEFAULT_PROJECT_CONFIG, config);
+  isRegistered = true;
+};
+var getProjectConfig = () => activeConfig;
+var isProjectConfigRegistered = () => isRegistered;
+
+// src/loggerRegistry.ts
+var defaultLogger = {
+  debug: (message, context) => {
+    if (context === void 0) {
+      console.debug(message);
+    } else {
+      console.debug(message, context);
+    }
+  },
+  info: (message, context) => {
+    if (context === void 0) {
+      console.info(message);
+    } else {
+      console.info(message, context);
+    }
+  },
+  warn: (message, context) => {
+    if (context === void 0) {
+      console.warn(message);
+    } else {
+      console.warn(message, context);
+    }
+  },
+  error: (message, error, context) => {
+    if (error !== void 0 && context !== void 0) console.error(message, error, context);
+    else if (error !== void 0) console.error(message, error);
+    else if (context === void 0) {
+      console.error(message);
+    } else {
+      console.error(message, context);
+    }
+  }
+};
+var activeLogger = defaultLogger;
+var isRegistered2 = false;
+var registerLogger = (logger) => {
+  activeLogger = logger;
+  isRegistered2 = true;
+};
+var getLogger = () => activeLogger;
+
+// src/apiMethodMapRegistry.ts
+var activeMap = null;
+var registerApiMethodMap = (map) => {
+  activeMap = map;
+};
+var getRegisteredApiMethod = (pagePath, apiName, version) => {
+  if (!activeMap) return void 0;
+  return activeMap[pagePath]?.[apiName]?.[version];
+};
+var isApiMethodMapRegistered = () => activeMap !== null;
+
+// src/socketState.ts
+var socket = null;
+var setSocket = (next) => {
+  socket = next;
+};
+var responseIndex = 0;
+var WAIT_FOR_SOCKET_INTERVAL_MS = 10;
+var WAIT_FOR_SOCKET_MAX_ITERATIONS = 500;
+var incrementResponseIndex = () => {
+  responseIndex = responseIndex + 1;
+  return responseIndex;
+};
+var waitForSocket = async () => {
+  let i = 0;
+  while (!socket) {
+    await new Promise((resolve2) => setTimeout(resolve2, WAIT_FOR_SOCKET_INTERVAL_MS));
+    i++;
+    if (i > WAIT_FOR_SOCKET_MAX_ITERATIONS) {
+      return null;
+    }
+  }
+  return socket;
+};
+
+// src/notifier.ts
+var noopNotifier = {
+  success: () => {
+  },
+  error: () => {
+  },
+  info: () => {
+  },
+  warning: () => {
+  }
+};
+var activeNotifier = noopNotifier;
+var registerNotifier = (notifier) => {
+  activeNotifier = notifier;
+};
+var getNotifier = () => activeNotifier;
+var notify = {
+  success: (input) => {
+    activeNotifier.success(input);
+  },
+  error: (input) => {
+    activeNotifier.error(input);
+  },
+  info: (input) => {
+    activeNotifier.info(input);
+  },
+  warning: (input) => {
+    activeNotifier.warning(input);
+  }
+};
+
+// src/offlineQueue.ts
+var apiQueue = [];
+var syncQueue = [];
+var isFlushingApi = false;
+var isFlushingSync = false;
+var isOnline = () => {
+  if (typeof navigator === "undefined") return true;
+  return navigator.onLine;
+};
+var evictExpired = (queue) => {
+  const maxAgeMs = getProjectConfig().offlineQueue.maxAgeMs;
+  if (maxAgeMs <= 0) return;
+  const cutoff = Date.now() - maxAgeMs;
+  for (let i = queue.length - 1; i >= 0; i -= 1) {
+    const item = queue[i];
+    if (item && item.createdAt < cutoff) {
+      queue.splice(i, 1);
+    }
+  }
+};
+var enqueueWithPolicy = (queue, item, label) => {
+  evictExpired(queue);
+  const { maxSize, dropPolicy: globalPolicy } = getProjectConfig().offlineQueue;
+  const effectivePolicy = item.dropPolicy ?? globalPolicy;
+  if (queue.length < maxSize) {
+    queue.push(item);
+    return true;
+  }
+  if (effectivePolicy === "drop-oldest") {
+    queue.shift();
+    queue.push(item);
+    getLogger().debug(`offlineQueue:${label} full \u2014 dropped oldest item (policy=${effectivePolicy})`);
+    return true;
+  }
+  if (effectivePolicy === "drop-newest") {
+    getLogger().debug(`offlineQueue:${label} full \u2014 dropped newest item (policy=${effectivePolicy})`);
+    return false;
+  }
+  getLogger().warn(`offlineQueue:${label} full \u2014 rejecting enqueue (policy=${effectivePolicy})`);
+  return false;
+};
+var enqueueApiRequest = (item) => enqueueWithPolicy(apiQueue, item, "api");
+var enqueueSyncRequest = (item) => enqueueWithPolicy(syncQueue, item, "sync");
+var removeApiQueueItem = (id) => {
+  const index = apiQueue.findIndex((item) => item.id === id);
+  if (index !== -1) {
+    apiQueue.splice(index, 1);
+  }
+};
+var removeSyncQueueItem = (id) => {
+  const index = syncQueue.findIndex((item) => item.id === id);
+  if (index !== -1) {
+    syncQueue.splice(index, 1);
+  }
+};
+var removeApiQueueItemsByKey = (key) => {
+  for (let i = apiQueue.length - 1; i >= 0; i -= 1) {
+    if (apiQueue[i]?.key === key) {
+      apiQueue.splice(i, 1);
+    }
+  }
+};
+var flushApiQueue = (canRun, socketInstance) => {
+  if (isFlushingApi) return;
+  evictExpired(apiQueue);
+  if (apiQueue.length === 0) return;
+  if (!canRun()) return;
+  isFlushingApi = true;
+  while (apiQueue.length > 0) {
+    if (!canRun()) break;
+    const item = apiQueue.shift();
+    item?.run(socketInstance);
+  }
+  isFlushingApi = false;
+};
+var flushSyncQueue = (canRun, socketInstance) => {
+  if (isFlushingSync) return;
+  evictExpired(syncQueue);
+  if (syncQueue.length === 0) return;
+  if (!canRun()) return;
+  isFlushingSync = true;
+  while (syncQueue.length > 0) {
+    if (!canRun()) break;
+    const item = syncQueue.shift();
+    item?.run(socketInstance);
+  }
+  isFlushingSync = false;
+};
+var getApiQueueSize = () => apiQueue.length;
+var getSyncQueueSize = () => syncQueue.length;
+
+// src/responseNormalizer.ts
+var INVALID_ERROR_RESPONSE_CODE = "error.invalidResponse";
+var isErrorParamArray = (value) => {
+  return Array.isArray(value) && value.every((item) => {
+    return !!item && typeof item === "object" && typeof item.key === "string" && ["string", "number", "boolean"].includes(typeof item.value);
+  });
+};
+var normalizeErrorResponseCore = ({
+  response,
+  fallbackHttpStatus,
+  fallbackErrorCode,
+  resolveMessage
+}) => {
+  const normalizedParams = isErrorParamArray(response.errorParams) ? response.errorParams : void 0;
+  const errorCodeValue = typeof response.errorCode === "string" ? response.errorCode.trim() : "";
+  const hasErrorCode = errorCodeValue.length > 0;
+  const finalErrorCode = hasErrorCode ? errorCodeValue : fallbackErrorCode ?? INVALID_ERROR_RESPONSE_CODE;
+  const providedHttpStatus = typeof response.httpStatus === "number" ? response.httpStatus : void 0;
+  const message = resolveMessage ? resolveMessage({ errorCode: finalErrorCode, errorParams: normalizedParams }) : finalErrorCode;
+  return {
+    status: "error",
+    message,
+    errorCode: finalErrorCode,
+    errorParams: normalizedParams,
+    httpStatus: providedHttpStatus ?? fallbackHttpStatus
+  };
+};
+
+// src/serviceRoute.ts
+var normalizeRawRoute = (value) => {
+  return value.trim().replaceAll("\\", "/").replaceAll(/^\/+/g, "").replaceAll(/\/+$/g, "");
+};
+var hasEmptySegments = (value) => {
+  return value.split("/").some((segment) => segment.length === 0);
+};
+var parseServiceRouteName = (value) => {
+  const normalized = normalizeRawRoute(value);
+  if (!normalized) {
+    return { status: "error", reason: "Route name cannot be empty." };
+  }
+  if (hasEmptySegments(normalized)) {
+    return { status: "error", reason: "Route name cannot contain empty segments." };
+  }
+  const segments = normalized.split("/");
+  if (segments.length < 2) {
+    return { status: "error", reason: "Route name must include service and route segments." };
+  }
+  const [service, ...routeSegments] = segments;
+  const routeName = routeSegments.join("/");
+  if (!service || !routeName) {
+    return { status: "error", reason: "Route name must include service and route segments." };
+  }
+  return {
+    status: "success",
+    normalizedRouteName: `${service}/${routeName}`,
+    service,
+    routeName
+  };
+};
+
+// src/socketEvents.ts
+var withIndex = (prefix, responseIndex2) => {
+  return `${prefix}${String(responseIndex2)}`;
+};
+var socketEventNames = {
+  apiRequest: "apiRequest",
+  apiCancel: "apiCancel",
+  sync: "sync",
+  syncCancel: "syncCancel",
+  joinRoom: "joinRoom",
+  leaveRoom: "leaveRoom",
+  getJoinedRooms: "getJoinedRooms",
+  updateLocation: "updateLocation",
+  updateSession: "updateSession",
+  sessionReplaced: "sessionReplaced",
+  logout: "logout",
+  intentionalDisconnect: "intentionalDisconnect",
+  intentionalReconnect: "intentionalReconnect",
+  userAfk: "userAfk",
+  userBack: "userBack",
+  connect: "connect",
+  disconnect: "disconnect",
+  reconnectAttempt: "reconnect_attempt",
+  connectError: "connect_error",
+  apiResponsePrefix: "apiResponse-",
+  apiStreamPrefix: "apiStream-",
+  syncResponsePrefix: "sync-",
+  syncProgressPrefix: "sync-progress-",
+  joinRoomResponsePrefix: "joinRoom-",
+  leaveRoomResponsePrefix: "leaveRoom-",
+  getJoinedRoomsResponsePrefix: "getJoinedRooms-"
+};
+var buildApiResponseEventName = (responseIndex2) => {
+  return withIndex(socketEventNames.apiResponsePrefix, responseIndex2);
+};
+var buildApiStreamEventName = (responseIndex2) => {
+  return withIndex(socketEventNames.apiStreamPrefix, responseIndex2);
+};
+var buildSyncResponseEventName = (responseIndex2) => {
+  return withIndex(socketEventNames.syncResponsePrefix, responseIndex2);
+};
+var buildSyncProgressEventName = (responseIndex2) => {
+  return withIndex(socketEventNames.syncProgressPrefix, responseIndex2);
+};
+var buildJoinRoomResponseEventName = (responseIndex2) => {
+  return withIndex(socketEventNames.joinRoomResponsePrefix, responseIndex2);
+};
+var buildLeaveRoomResponseEventName = (responseIndex2) => {
+  return withIndex(socketEventNames.leaveRoomResponsePrefix, responseIndex2);
+};
+var buildGetJoinedRoomsResponseEventName = (responseIndex2) => {
+  return withIndex(socketEventNames.getJoinedRoomsResponsePrefix, responseIndex2);
+};
+
+// src/apiRequest.ts
+var abortControllers = /* @__PURE__ */ new Map();
+var isGetMethodByPrefix = (apiName) => {
+  const lower = apiName.toLowerCase();
+  return lower.startsWith("get") || lower.startsWith("fetch") || lower.startsWith("list");
+};
+var isGetMethod = (apiName, version) => {
+  const lastSlash = apiName.lastIndexOf("/");
+  if (lastSlash > 0) {
+    const pagePath = apiName.slice(0, lastSlash);
+    const leaf = apiName.slice(lastSlash + 1);
+    const method = getRegisteredApiMethod(pagePath, leaf, version);
+    if (method) return method === "GET";
+  }
+  return isGetMethodByPrefix(apiName);
+};
+var canSendNow = (socketInstance) => {
+  if (!socketInstance.connected) return false;
+  return isOnline();
+};
+var createQueueId = () => {
+  return `${String(Date.now())}-${String(Math.random())}`;
+};
+var getLogging = () => getProjectConfig().logging;
+var shouldLogDev = () => getLogging().devLogs;
+var shouldNotifyDev = () => getLogging().devNotifications;
+var shouldLogStream = () => getLogging().stream;
+var shouldUseAbortController = ({
+  abortable,
+  isGet
+}) => {
+  if (abortable === true) return true;
+  if (abortable === false) return false;
+  return isGet;
+};
+var normalizeApiError = ({
+  response,
+  fallbackErrorCode,
+  fallbackHttpStatus = 500
+}) => {
+  const normalized = normalizeErrorResponseCore({
+    response,
+    fallbackErrorCode,
+    fallbackHttpStatus,
+    resolveMessage: ({ errorCode }) => {
+      if (typeof response.message === "string" && response.message.trim().length > 0) {
+        return response.message;
+      }
+      return errorCode;
+    }
+  });
+  return {
+    status: "error",
+    message: normalized.message,
+    errorCode: normalized.errorCode,
+    errorParams: normalized.errorParams,
+    httpStatus: normalized.httpStatus ?? fallbackHttpStatus
+  };
+};
+function apiRequest(params) {
+  const runtimeParams = params;
+  const { name, version, disableErrorMessage = false, onStream, signal: externalSignal } = runtimeParams;
+  const payloadData = runtimeParams.data;
+  return new Promise((resolve2, reject) => {
+    void (async () => {
+      if (externalSignal?.aborted) {
+        resolve2(normalizeApiError({
+          response: { status: "error", errorCode: "request.aborted" },
+          fallbackErrorCode: "request.aborted"
+        }));
+        return;
+      }
+      if (!name || typeof name !== "string") {
+        if (shouldLogDev()) {
+          getLogger().error("apiRequest: Invalid name");
+        }
+        if (shouldNotifyDev()) {
+          notify.error({ key: "api.invalidName" });
+        }
+        resolve2(normalizeApiError({
+          response: { status: "error", errorCode: "api.invalidName" },
+          fallbackErrorCode: "api.invalidName"
+        }));
+        return;
+      }
+      if (!version || typeof version !== "string") {
+        if (shouldLogDev()) {
+          getLogger().error("apiRequest: Invalid version");
+        }
+        if (shouldNotifyDev()) {
+          notify.error({ key: "api.invalidVersion" });
+        }
+        resolve2(normalizeApiError({
+          response: { status: "error", errorCode: "api.invalidVersion" },
+          fallbackErrorCode: "api.invalidVersion"
+        }));
+        return;
+      }
+      const parsedRoute = parseServiceRouteName(name);
+      if (parsedRoute.status === "error") {
+        if (shouldLogDev()) {
+          getLogger().error(`[apiRequest] Invalid service route name`, void 0, { name, reason: parsedRoute.reason });
+        }
+        if (shouldNotifyDev()) {
+          notify.error({ key: "routing.invalidServiceRouteName" });
+        }
+        resolve2(normalizeErrorResponseCore({
+          response: {
+            status: "error",
+            errorCode: "routing.invalidServiceRouteName",
+            errorParams: [{ key: "name", value: name }]
+          },
+          fallbackErrorCode: "routing.invalidServiceRouteName"
+        }));
+        return;
+      }
+      const sanitizedName = parsedRoute.normalizedRouteName;
+      const data = payloadData && typeof payloadData === "object" ? payloadData : {};
+      if (!await waitForSocket()) {
+        resolve2(normalizeApiError({
+          response: { status: "error", errorCode: "api.ioUnavailable" },
+          fallbackErrorCode: "api.ioUnavailable"
+        }));
+        return;
+      }
+      if (!socket) {
+        resolve2(normalizeApiError({
+          response: { status: "error", errorCode: "api.ioUnavailable" },
+          fallbackErrorCode: "api.ioUnavailable"
+        }));
+        return;
+      }
+      const isGet = isGetMethod(sanitizedName, version);
+      const useAbortController = shouldUseAbortController({
+        abortable: runtimeParams.abortable,
+        isGet
+      });
+      const fullName = `api/${sanitizedName}/${version}`;
+      let signal = null;
+      let abortHandler = null;
+      let queueId = null;
+      let cleanupStreamListener = null;
+      const cleanupAbortController = () => {
+        if (signal && abortHandler) {
+          signal.removeEventListener("abort", abortHandler);
+        }
+        abortControllers.delete(fullName);
+      };
+      if (useAbortController) {
+        if (abortControllers.has(fullName)) {
+          const prevAbortController = abortControllers.get(fullName);
+          prevAbortController?.abort();
+        }
+        const abortController = new AbortController();
+        abortControllers.set(fullName, abortController);
+        signal = abortController.signal;
+        abortHandler = () => {
+          cleanupStreamListener?.();
+          cleanupStreamListener = null;
+          cleanupAbortController();
+          if (queueId) {
+            removeApiQueueItem(queueId);
+          }
+          reject(new Error(`Request ${fullName} aborted`));
+        };
+        signal.addEventListener("abort", abortHandler);
+      }
+      const runRequest = (socketInstance) => {
+        if (!canSendNow(socketInstance)) {
+          queueId ??= createQueueId();
+          const enqueued = enqueueApiRequest({
+            id: queueId,
+            key: fullName,
+            run: (nextSocket) => {
+              runRequest(nextSocket);
+            },
+            createdAt: Date.now()
+          });
+          if (!enqueued) {
+            resolve2(normalizeApiError({
+              response: { status: "error", errorCode: "offline.queueFull", httpStatus: 503 },
+              fallbackErrorCode: "offline.queueFull",
+              fallbackHttpStatus: 503
+            }));
+          }
+          return;
+        }
+        if (signal?.aborted) {
+          return;
+        }
+        const tempIndex = incrementResponseIndex();
+        socketInstance.emit(socketEventNames.apiRequest, { name: fullName, data, responseIndex: tempIndex });
+        let cleanupExternalAbort = null;
+        if (externalSignal) {
+          const externalAbortHandler = () => {
+            socketInstance.emit(socketEventNames.apiCancel, { responseIndex: tempIndex });
+            cleanupStreamListener?.();
+            cleanupStreamListener = null;
+            cleanupAbortController();
+            cleanupExternalAbort?.();
+            cleanupExternalAbort = null;
+            resolve2(normalizeApiError({
+              response: { status: "error", errorCode: "request.aborted" },
+              fallbackErrorCode: "request.aborted"
+            }));
+          };
+          externalSignal.addEventListener("abort", externalAbortHandler);
+          cleanupExternalAbort = () => {
+            externalSignal.removeEventListener("abort", externalAbortHandler);
+          };
+        }
+        if (typeof onStream === "function") {
+          const streamEventName = buildApiStreamEventName(tempIndex);
+          const streamListener = (streamPayload) => {
+            if (signal?.aborted) {
+              return;
+            }
+            if (shouldLogStream()) {
+              getLogger().debug(`Server API Stream(${String(tempIndex)})`, { APINAME: sanitizedName, streamPayload });
+            }
+            onStream(streamPayload);
+          };
+          socketInstance.on(streamEventName, streamListener);
+          cleanupStreamListener = () => {
+            socketInstance.off(streamEventName, streamListener);
+          };
+        }
+        if (shouldLogDev()) {
+          getLogger().debug(`Client API Request(${String(tempIndex)})`, { APINAME: sanitizedName, data });
+        }
+        socketInstance.once(buildApiResponseEventName(tempIndex), (response) => {
+          if (signal?.aborted) {
+            cleanupExternalAbort?.();
+            cleanupExternalAbort = null;
+            return;
+          }
+          cleanupStreamListener?.();
+          cleanupStreamListener = null;
+          cleanupExternalAbort?.();
+          cleanupExternalAbort = null;
+          const status = response.status;
+          if (shouldLogDev()) {
+            getLogger().debug(`Server API Response(${String(tempIndex)})`, { ...response, APINAME: sanitizedName });
+          }
+          if (status === "error") {
+            const normalizedError = normalizeErrorResponseCore({ response });
+            if (!disableErrorMessage) {
+              if (normalizedError.errorCode) {
+                notify.error({ key: normalizedError.errorCode, params: normalizedError.errorParams });
+              } else {
+                notify.error({ key: normalizedError.message });
+              }
+            }
+            Object.assign(response, normalizedError);
+            cleanupAbortController();
+            resolve2(response);
+            return;
+          }
+          cleanupAbortController();
+          resolve2(response);
+        });
+      };
+      runRequest(socket);
+    })();
+  });
+}
+
+// src/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
+// src/errorTrackerRegistry.ts
+var activeTrackers = [];
+var captureExceptionAcrossTrackers = (error, context) => {
+  for (const tracker of activeTrackers) {
+    try {
+      tracker.captureException(error, context);
+    } catch {
+    }
+  }
+};
+
+// src/sentrySetup.ts
+var sentry;
+var captureException = (error, context) => {
+  if (sentry) {
+    if (context) {
+      sentry.captureException(error, { extra: context });
+    } else {
+      sentry.captureException(error);
+    }
+  }
+  captureExceptionAcrossTrackers(error, context);
+};
+
+// src/tryCatch.ts
+async function tryCatch(func, params, context) {
+  try {
+    const response = await func(params);
+    return [null, response];
+  } catch (error) {
+    captureException(error, context);
+    return [error, null];
+  }
+}
+
+// src/csrfConfig.ts
+var DEFAULT_CSRF_CONFIG = {
+  cookieName: "csrf-token",
+  headerName: "x-csrf-token",
+  tokenLength: 32,
+  cookieOptions: {
+    sameSite: "lax",
+    secure: true,
+    httpOnly: false,
+    path: "/",
+    maxAgeMs: 24 * 60 * 60 * 1e3
+  }
+};
+var active = DEFAULT_CSRF_CONFIG;
+var getCsrfConfig = () => active;
+
+// src/csrf.ts
+var cachedToken = null;
+var inflightFetch = null;
+var resolveBackendUrl = () => {
+  if (globalThis.window !== void 0 && globalThis.location?.origin) {
+    return globalThis.location.origin;
+  }
+  return "";
+};
+var fetchCsrfToken = async () => {
+  const base = resolveBackendUrl();
+  const [error, token] = await tryCatch(async () => {
+    const response = await fetch(`${base}/auth/csrf`, {
+      method: "GET",
+      credentials: "include"
+    });
+    if (!response.ok) return null;
+    const body = await response.json();
+    return body.csrfToken ?? null;
+  });
+  if (error) return null;
+  return token ?? null;
+};
+var getCsrfToken = async () => {
+  if (getProjectConfig().session.basedToken) {
+    return null;
+  }
+  if (cachedToken) return cachedToken;
+  if (inflightFetch) return inflightFetch;
+  inflightFetch = fetchCsrfToken().then((token) => {
+    cachedToken = token;
+    inflightFetch = null;
+    return token;
+  });
+  return inflightFetch;
+};
+var clearCsrfToken = () => {
+  cachedToken = null;
+  inflightFetch = null;
+};
+var STATE_CHANGING = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH", "DELETE"]);
+var isCsrfMismatchResponse = async (response) => {
+  if (response.status !== 403) return false;
+  const [error, isMismatch] = await tryCatch(async () => {
+    const cloned = response.clone();
+    const body = await cloned.json();
+    return body.errorCode === "auth.csrfMismatch";
+  });
+  if (error) return false;
+  return isMismatch ?? false;
+};
+var httpFetch = async (input, init = {}) => {
+  const method = (init.method ?? "GET").toUpperCase();
+  const headers = new Headers(init.headers);
+  if (!headers.has("Content-Type") && init.body && typeof init.body === "string") {
+    headers.set("Content-Type", "application/json");
+  }
+  const csrfHeaderName = getCsrfConfig().headerName;
+  const send = async (csrfToken) => {
+    const finalHeaders = new Headers(headers);
+    if (csrfToken && STATE_CHANGING.has(method) && !finalHeaders.has(csrfHeaderName)) {
+      finalHeaders.set(csrfHeaderName, csrfToken);
+    }
+    return fetch(input, {
+      ...init,
+      method,
+      headers: finalHeaders,
+      credentials: init.credentials ?? "include"
+    });
+  };
+  if (!STATE_CHANGING.has(method) || getProjectConfig().session.basedToken) {
+    return send(null);
+  }
+  const token = await getCsrfToken();
+  let response = await send(token);
+  if (await isCsrfMismatchResponse(response)) {
+    clearCsrfToken();
+    const refreshed = await getCsrfToken();
+    if (refreshed) {
+      response = await send(refreshed);
+    }
+  }
+  return response;
+};
+
+// src/localesRegistry.ts
+var activeLocales = {};
+var activeLanguageSource = null;
+var registerLocales = (locales) => {
+  activeLocales = locales;
+};
+var getRegisteredLocales = () => activeLocales;
+var getDefaultLocale = () => getProjectConfig().defaultLanguage || "en";
+var registerLanguageSource = (fn) => {
+  activeLanguageSource = fn;
+};
+var getActiveLanguage = () => {
+  if (activeLanguageSource) {
+    const lang = activeLanguageSource();
+    if (typeof lang === "string" && lang.length > 0) return lang;
+  }
+  return getDefaultLocale();
+};
+var getLocaleByCode = (code) => {
+  if (code in activeLocales) return activeLocales[code];
+  const fallback = getDefaultLocale();
+  if (fallback in activeLocales) return activeLocales[fallback];
+  return {};
+};
+
+// src/middlewareRegistry.ts
+var DEFAULT_HANDLER = () => ({ success: true });
+var activeHandler = DEFAULT_HANDLER;
+var registerMiddlewareHandler = (handler) => {
+  activeHandler = handler;
+};
+var getMiddlewareHandler = () => activeHandler;
+var pageMiddlewares = /* @__PURE__ */ new Map();
+var registerPageMiddleware = (path, middleware) => {
+  pageMiddlewares.set(path, middleware);
+};
+var getPageMiddleware = (path) => pageMiddlewares.get(path);
+var hasPageMiddleware = (path) => pageMiddlewares.has(path);
+
+// src/clientHookBus.ts
+var handlerSets = {};
+function registerClientHook(name, handler) {
+  const existing = handlerSets[name];
+  const set = existing ?? /* @__PURE__ */ new Set();
+  if (!existing) handlerSets[name] = set;
+  const wrapped = handler;
+  set.add(wrapped);
+  return () => {
+    set.delete(wrapped);
+  };
+}
+function dispatchClientHook(name, payload) {
+  const set = handlerSets[name];
+  if (!set || set.size === 0) return;
+  for (const handler of set) {
+    try {
+      const result = handler(payload);
+      if (result && typeof result.catch === "function") {
+        result.catch((error) => {
+          console.error(`[clientHook:${name}] async handler rejected:`, error);
+        });
+      }
+    } catch (error) {
+      console.error(`[clientHook:${name}] handler threw:`, error);
+    }
+  }
+}
+async function dispatchVetoableClientHook(name, payload) {
+  const set = handlerSets[name];
+  if (!set || set.size === 0) return { stopped: false };
+  for (const handler of set) {
+    let result;
+    try {
+      result = await handler(payload);
+    } catch (error) {
+      console.error(`[clientHook:${name}] vetoable handler threw:`, error);
+      continue;
+    }
+    if (result?.stop) {
+      return { stopped: true, signal: result };
+    }
+  }
+  return { stopped: false };
+}
+
+// src/pageRouteValidation.ts
+var DEFAULT_PAGE_ROUTE_RULES = {
+  privateFolderPrefix: "_",
+  scaffoldIgnoredFolders: [
+    "_api",
+    "_sync",
+    "_function",
+    "_functions",
+    "_component",
+    "_components",
+    "_provider",
+    "_providers",
+    "_locale",
+    "_locales",
+    "_socket",
+    "_sockets",
+    "_shared",
+    "_server"
+  ]
+};
+var validatePagePath = (srcRelativePath, rules = DEFAULT_PAGE_ROUTE_RULES) => {
+  const normalized = srcRelativePath.replaceAll("\\", "/").replace(/^\.\//, "").replace(/^\/+/, "");
+  const segments = normalized.split("/").filter((segment) => segment.length > 0);
+  if (segments.length === 0) {
+    return { valid: false, reason: "empty path" };
+  }
+  const filename = segments.at(-1);
+  if (filename !== "page.tsx" && filename !== "page.jsx") {
+    return { valid: false, reason: "not a page file (expected page.tsx)" };
+  }
+  const folderSegments = segments.slice(0, -1);
+  const prefix = rules.privateFolderPrefix;
+  const reserved = rules.scaffoldIgnoredFolders;
+  for (const reservedName of reserved) {
+    if (folderSegments.includes(reservedName)) {
+      return { valid: false, reason: `page.tsx cannot live inside reserved folder ${reservedName}` };
+    }
+  }
+  const visibleSegments = folderSegments.filter((segment) => !segment.startsWith(prefix));
+  if (folderSegments.length > 0 && visibleSegments.length === 0) {
+    return { valid: false, reason: "no URL segment left after stripping underscore folders" };
+  }
+  const route = visibleSegments.length === 0 ? "/" : `/${visibleSegments.join("/")}`;
+  return { valid: true, route };
+};
+
+// src/react/sessionContext.ts
+import { createContext, use } from "react";
+var DEFAULT_VALUE = {
+  session: null,
+  sessionLoaded: false
+};
+var SessionContext = createContext(DEFAULT_VALUE);
+function useSession() {
+  return use(SessionContext);
+}
+var latestSession = null;
+var setLatestSession = (session) => {
+  const previous = latestSession;
+  latestSession = session;
+  if (previous === null && session !== null) {
+    dispatchClientHook("postLogin", { session });
+  } else if (previous !== null && session === null) {
+    dispatchClientHook("postLogout", { previousSession: previous });
+  }
+};
+var getCurrentSession = () => latestSession;
+var proposeLogin = async (session) => {
+  const veto = await dispatchVetoableClientHook("preLogin", { candidateSession: session });
+  if (veto.stopped) return { stopped: true, signal: veto.signal, committed: false };
+  setLatestSession(session);
+  return { stopped: false, committed: true };
+};
+
+// src/react/AvatarProvider.tsx
+import { createContext as createContext2, use as use2, useState, useMemo, useCallback } from "react";
+import { jsx } from "react/jsx-runtime";
+var AvatarContext = createContext2(null);
+var AvatarProvider = ({ children }) => {
+  const [avatarStatuses, setAvatarStatuses] = useState({});
+  const setAvatarStatus = useCallback((key, status) => {
+    setAvatarStatuses((prev) => ({ ...prev, [key]: status }));
+  }, []);
+  const contextValue = useMemo(() => ({
+    avatarStatuses,
+    setAvatarStatus
+  }), [avatarStatuses, setAvatarStatus]);
+  return /* @__PURE__ */ jsx(AvatarContext, { value: contextValue, children });
+};
+function useAvatarContext() {
+  const ctx = use2(AvatarContext);
+  if (!ctx) throw new Error("useAvatarContext must be used within AvatarProvider");
+  return ctx;
+}
+
+// src/react/useTheme.ts
+import { useState as useState2, useCallback as useCallback2 } from "react";
+var applyDomClass = (theme) => {
+  if (typeof document === "undefined") return;
+  document.documentElement.classList.toggle("dark", theme === "dark");
+};
+var useTheme = () => {
+  const initialTheme = getProjectConfig().defaultTheme ?? "light";
+  const [theme, setThemeState] = useState2(initialTheme);
+  const setTheme = useCallback2((next) => {
+    setThemeState(next);
+    applyDomClass(next);
+  }, []);
+  return { theme, setTheme };
+};
+
+// src/react/TranslationProvider.tsx
+import { createContext as createContext3, use as use3, useEffect, useMemo as useMemo2, useState as useState3 } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var TranslationContext = createContext3(null);
+var resolveTranslations = (code) => {
+  const value = getLocaleByCode(code);
+  if (value && typeof value === "object") return value;
+  return {};
+};
+function TranslationProvider({ children }) {
+  const [language, setLanguage] = useState3(() => getActiveLanguage());
+  const translations = useMemo2(() => resolveTranslations(language), [language]);
+  useEffect(() => {
+    const handle = window.setInterval(() => {
+      const next = getActiveLanguage();
+      if (next !== language) setLanguage(next);
+    }, 250);
+    return () => {
+      window.clearInterval(handle);
+    };
+  }, [language]);
+  const contextValue = useMemo2(() => ({ translations, setLanguage }), [translations]);
+  return /* @__PURE__ */ jsx2(TranslationContext, { value: contextValue, children });
+}
+function useTranslation() {
+  const context = use3(TranslationContext);
+  if (!context) throw new Error("useTranslation must be used within a TranslationProvider");
+  return context.translations;
+}
+function useUpdateLanguage() {
+  const context = use3(TranslationContext);
+  if (!context) throw new Error("useUpdateLanguage must be used within a TranslationProvider");
+  return context.setLanguage;
+}
+function translate({ translationList, key, params }) {
+  if (typeof key !== "string" || key.length === 0) return "";
+  const parts = key.split(".");
+  let result = translationList;
+  for (const part of parts) {
+    if (result && typeof result === "object" && part in result) {
+      result = result[part];
+    } else {
+      return key;
+    }
+  }
+  if (typeof result !== "string") return key;
+  if (!Array.isArray(params) || params.length === 0) return result;
+  let finalResult = result;
+  for (const param of params) {
+    if (!param.key) continue;
+    const regex = new RegExp(`\\{\\{${param.key}\\}\\}`, "g");
+    finalResult = finalResult.replace(regex, String(param.value));
+  }
+  return finalResult;
+}
+var useTranslator = () => {
+  const translations = useTranslation();
+  return ({ key, params }) => translate({ translationList: translations, key, params });
+};
+
+// src/react/notify.ts
+import { toast } from "sonner";
+var resolve = (input) => {
+  const language = getActiveLanguage();
+  const list = getLocaleByCode(language);
+  return translate({
+    translationList: list && typeof list === "object" ? list : {},
+    key: input.key,
+    params: input.params
+  });
+};
+var notify2 = {
+  success: (input) => {
+    toast.success(resolve(input));
+  },
+  error: (input) => {
+    toast.error(resolve(input));
+  },
+  info: (input) => {
+    toast.info(resolve(input));
+  },
+  warning: (input) => {
+    toast.warning(resolve(input));
+  }
+};
+registerNotifier(notify2);
+var notify_default = notify2;
+
+// src/react/Middleware.tsx
+import { useEffect as useEffect2, useRef, useState as useState4 } from "react";
+import { useLocation, useNavigate } from "react-router-dom";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var LOADER_DELAY_MS = 200;
+function MiddlewareLoader() {
+  const [show, setShow] = useState4(false);
+  useEffect2(() => {
+    const id = globalThis.setTimeout(() => {
+      setShow(true);
+    }, LOADER_DELAY_MS);
+    return () => {
+      globalThis.clearTimeout(id);
+    };
+  }, []);
+  if (!show) return null;
+  return /* @__PURE__ */ jsx3("div", { className: "w-full h-full flex items-center justify-center", "aria-busy": "true", "aria-live": "polite", children: /* @__PURE__ */ jsx3(
+    "div",
+    {
+      className: "w-8 h-8 rounded-full border-2 border-container2-border border-t-primary animate-spin",
+      role: "status",
+      "aria-label": "Loading"
+    }
+  ) });
+}
+function Middleware({ children }) {
+  const [allowed, setAllowed] = useState4(false);
+  const [checking, setChecking] = useState4(true);
+  const location = useLocation();
+  const navigate = useNavigate();
+  const { session, sessionLoaded } = useSession();
+  const routeKey = `${location.pathname}\0${location.search}`;
+  const guardedRouteRef = useRef(null);
+  useEffect2(() => {
+    let isMounted = true;
+    const isRouteChange = guardedRouteRef.current !== routeKey;
+    guardedRouteRef.current = routeKey;
+    if (isRouteChange) {
+      setAllowed(false);
+      setChecking(true);
+    }
+    void (async () => {
+      const params = new URLSearchParams(location.search);
+      const queryObject = {};
+      for (const [key, value] of params.entries()) {
+        queryObject[key] = value;
+      }
+      let count = 0;
+      while (!sessionLoaded) {
+        await new Promise((res) => setTimeout(res, 10));
+        count++;
+        if (count > 500) break;
+      }
+      const pageMw = getPageMiddleware(location.pathname);
+      const handler = pageMw ?? getMiddlewareHandler();
+      const result = await handler({
+        location: location.pathname,
+        searchParams: queryObject,
+        session
+      });
+      if (!isMounted) return;
+      if (result?.success) {
+        setAllowed(true);
+      } else if (result?.redirect) {
+        void navigate(result.redirect);
+      } else {
+        void navigate(-1);
+      }
+      setChecking(false);
+    })();
+    return () => {
+      isMounted = false;
+    };
+  }, [routeKey, location.pathname, location.search, navigate, session, sessionLoaded]);
+  if (checking) return /* @__PURE__ */ jsx3(MiddlewareLoader, {});
+  if (!allowed) return null;
+  return /* @__PURE__ */ jsx3("div", { className: "w-full h-full", children });
+}
+
+// src/react/Router.tsx
+import { useLocation as useLocation2, useNavigate as useNavigate2 } from "react-router-dom";
+var getParams = (locationSearch) => {
+  const params = new URLSearchParams(locationSearch);
+  const queryObject = {};
+  for (const [key, value] of params.entries()) {
+    queryObject[key] = value;
+  }
+  return queryObject;
+};
+function useRouter() {
+  const navigateHandler = useNavigate2();
+  const location = useLocation2();
+  const { session } = useSession();
+  const navigate = async (path) => {
+    const queryObject = getParams(location.search);
+    const pageMw = getPageMiddleware(path);
+    const handler = pageMw ?? getMiddlewareHandler();
+    const result = await handler({ location: path, searchParams: queryObject, session });
+    if (result?.success) {
+      return navigateHandler(path);
+    }
+    if (result && !result.success && result.redirect) {
+      return navigateHandler(result.redirect);
+    }
+    return;
+  };
+  return navigate;
+}
+export {
+  AvatarProvider,
+  DEFAULT_PAGE_ROUTE_RULES,
+  Middleware,
+  SessionContext,
+  TranslationProvider,
+  apiRequest,
+  buildApiResponseEventName,
+  buildApiStreamEventName,
+  buildGetJoinedRoomsResponseEventName,
+  buildJoinRoomResponseEventName,
+  buildLeaveRoomResponseEventName,
+  buildSyncProgressEventName,
+  buildSyncResponseEventName,
+  clearCsrfToken,
+  dispatchClientHook,
+  dispatchVetoableClientHook,
+  enqueueApiRequest,
+  enqueueSyncRequest,
+  flushApiQueue,
+  flushSyncQueue,
+  getActiveLanguage,
+  getApiQueueSize,
+  getCsrfToken,
+  getCurrentSession,
+  getDefaultLocale,
+  getLocaleByCode,
+  getLogger,
+  getMiddlewareHandler,
+  getNotifier,
+  getPageMiddleware,
+  getProjectConfig,
+  getRegisteredApiMethod,
+  getRegisteredLocales,
+  getSyncQueueSize,
+  hasPageMiddleware,
+  httpFetch,
+  notify_default as i18nNotify,
+  incrementResponseIndex,
+  isApiMethodMapRegistered,
+  isOnline,
+  isProjectConfigRegistered,
+  normalizeErrorResponseCore,
+  notify,
+  parseServiceRouteName,
+  proposeLogin,
+  registerApiMethodMap,
+  registerClientHook,
+  registerLanguageSource,
+  registerLocales,
+  registerLogger,
+  registerMiddlewareHandler,
+  registerNotifier,
+  registerPageMiddleware,
+  registerProjectConfig,
+  removeApiQueueItem,
+  removeApiQueueItemsByKey,
+  removeSyncQueueItem,
+  setLatestSession,
+  setSocket,
+  sleep,
+  socket,
+  socketEventNames,
+  translate,
+  tryCatch,
+  useAvatarContext,
+  useRouter,
+  useSession,
+  useTheme,
+  useTranslation,
+  useTranslator,
+  useUpdateLanguage,
+  validatePagePath,
+  waitForSocket
+};
+//! isMounted check is load-bearing — without it, repeated middleware
+//# sourceMappingURL=client.js.map