@luckystack/core 0.1.0

package/dist/index.js

@@ -0,0 +1,2619 @@
+// src/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/errorTrackerRegistry.ts
+var activeTrackers = [];
+var registerErrorTracker = (tracker) => {
+  activeTrackers = [tracker];
+};
+var registerErrorTrackers = (trackers) => {
+  activeTrackers = [...trackers];
+};
+var getActiveErrorTrackers = () => activeTrackers;
+var captureExceptionAcrossTrackers = (error, context) => {
+  for (const tracker of activeTrackers) {
+    try {
+      tracker.captureException(error, context);
+    } catch {
+    }
+  }
+};
+var captureMessageAcrossTrackers = (message, level, context) => {
+  for (const tracker of activeTrackers) {
+    try {
+      tracker.captureMessage(message, level, context);
+    } catch {
+    }
+  }
+};
+var setErrorTrackerUser = (user) => {
+  for (const tracker of activeTrackers) {
+    try {
+      tracker.setUser(user);
+    } catch {
+    }
+  }
+};
+var recordMetricAcrossTrackers = (name, value, tags) => {
+  for (const tracker of activeTrackers) {
+    if (tracker.recordMetric) {
+      try {
+        tracker.recordMetric(name, value, tags);
+      } catch {
+      }
+    }
+  }
+};
+var startSpanAcrossTrackers = (name, op, fn) => {
+  const first = activeTrackers.find((t) => t.startSpan);
+  if (!first?.startSpan) return fn();
+  return first.startSpan(name, op, fn);
+};
+
+// src/sentrySetup.ts
+var sentry;
+var initSharedSentry = (instance) => {
+  sentry = instance;
+};
+var captureException = (error, context) => {
+  if (sentry) {
+    if (context) {
+      sentry.captureException(error, { extra: context });
+    } else {
+      sentry.captureException(error);
+    }
+  }
+  captureExceptionAcrossTrackers(error, context);
+};
+var captureMessage = (message, level = "info", context) => {
+  if (sentry) {
+    if (context) {
+      sentry.captureMessage(message, { level, extra: context });
+    } else {
+      sentry.captureMessage(message, level);
+    }
+  }
+  captureMessageAcrossTrackers(message, level, context);
+};
+var setSentryUser = (user) => {
+  sentry?.setUser(user);
+  setErrorTrackerUser(user);
+};
+var startSpan = (name, op) => {
+  if (sentry?.startInactiveSpan) {
+    return sentry.startInactiveSpan({ name, op });
+  }
+  startSpanAcrossTrackers(name, op, () => {
+  });
+};
+
+// 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/serviceRoute.ts
+var VERSION_SEGMENT_REGEX = /^v\d+$/;
+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
+  };
+};
+var parseTransportRouteName = ({
+  value,
+  prefix
+}) => {
+  const normalized = normalizeRawRoute(value);
+  if (!normalized) {
+    return { status: "error", reason: "Transport route cannot be empty." };
+  }
+  if (hasEmptySegments(normalized)) {
+    return { status: "error", reason: "Transport route cannot contain empty segments." };
+  }
+  const segments = normalized.split("/");
+  const routeSegments = segments[0] === prefix ? segments.slice(1) : segments;
+  if (routeSegments.length < 3) {
+    return {
+      status: "error",
+      reason: `Transport route must use ${prefix}/{service}/{name}/{version} format.`
+    };
+  }
+  const version = routeSegments.at(-1);
+  if (!version || !VERSION_SEGMENT_REGEX.test(version)) {
+    return { status: "error", reason: "Route version segment must match v{number}." };
+  }
+  const serviceRouteToken = routeSegments.slice(0, -1).join("/");
+  const serviceRoute = parseServiceRouteName(serviceRouteToken);
+  if (serviceRoute.status === "error") {
+    return {
+      status: "error",
+      reason: serviceRoute.reason
+    };
+  }
+  return {
+    status: "success",
+    normalizedFullName: `${prefix}/${serviceRoute.normalizedRouteName}/${version}`,
+    version,
+    serviceRoute
+  };
+};
+
+// 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/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
+  };
+};
+var defaultHttpStatusForResponse = ({
+  status,
+  explicitHttpStatus,
+  fallbackErrorStatus = 400
+}) => {
+  if (typeof explicitHttpStatus === "number") return explicitHttpStatus;
+  return status === "success" ? 200 : fallbackErrorStatus;
+};
+
+// 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 createDevLogger = () => ({
+  debug: (message, context) => {
+    if (context === void 0) {
+      console.log(message, "cyan");
+    } else {
+      console.log(message, context, "cyan");
+    }
+  },
+  info: (message, context) => {
+    if (context === void 0) {
+      console.log(message);
+    } else {
+      console.log(message, context);
+    }
+  },
+  warn: (message, context) => {
+    if (context === void 0) {
+      console.log(message, "yellow");
+    } else {
+      console.log(message, context, "yellow");
+    }
+  },
+  error: (message, error, context) => {
+    if (error !== void 0 && context !== void 0) console.log(message, error, context, "red");
+    else if (error !== void 0) console.log(message, error, "red");
+    else if (context === void 0) {
+      console.log(message, "red");
+    } else {
+      console.log(message, context, "red");
+    }
+  }
+});
+var activeLogger = defaultLogger;
+var isRegistered = false;
+var registerLogger = (logger) => {
+  activeLogger = logger;
+  isRegistered = true;
+};
+var getLogger = () => activeLogger;
+var isLoggerRegistered = () => isRegistered;
+var resetLoggerForTests = () => {
+  activeLogger = defaultLogger;
+  isRegistered = false;
+};
+
+// src/hooks/registry.ts
+var hookHandlers = /* @__PURE__ */ new Map();
+var registerHook = (name, handler) => {
+  const existing = hookHandlers.get(name) ?? [];
+  existing.push(handler);
+  hookHandlers.set(name, existing);
+};
+var dispatchHook = async (name, payload) => {
+  const handlers = hookHandlers.get(name) ?? [];
+  for (const handler of handlers) {
+    let result;
+    try {
+      result = await handler(payload);
+    } catch (error) {
+      getLogger().error(`hook: handler for "${name}" threw`, error, { hook: name });
+      captureException(error, { hook: name });
+      continue;
+    }
+    if (result !== void 0) {
+      return { stopped: true, signal: result };
+    }
+  }
+  return { stopped: false };
+};
+var clearAllHooks = () => {
+  hookHandlers.clear();
+  syncHookHandlers.clear();
+};
+var syncHookHandlers = /* @__PURE__ */ new Map();
+var registerSyncHook = (name, handler) => {
+  const existing = syncHookHandlers.get(name) ?? [];
+  existing.push(handler);
+  syncHookHandlers.set(name, existing);
+};
+var dispatchSyncHook = (name, payload) => {
+  const handlers = syncHookHandlers.get(name) ?? [];
+  for (const handler of handlers) {
+    try {
+      handler(payload);
+    } catch (error) {
+      getLogger().error(`hook: sync handler for "${name}" threw`, error, { hook: name });
+      captureException(error, { hook: name });
+    }
+  }
+};
+
+// src/localizedNormalizer.ts
+var normalizeLanguageCode = (language, isSupported) => {
+  if (!language) return null;
+  const short = language.toLowerCase().split("-")[0];
+  if (!short) return null;
+  return isSupported(short) ? short : null;
+};
+var createLocalizedNormalizer = (input) => {
+  const defaultLanguage = input.defaultLanguage ?? "en";
+  const isSupported = input.isSupportedLanguage ?? (() => true);
+  const extractLanguageFromHeader2 = (header) => {
+    if (!header) return null;
+    const normalized = Array.isArray(header) ? header.join(",") : header;
+    const candidates = normalized.split(",").map((part) => part.trim().split(";")[0]).filter(Boolean);
+    for (const candidate of candidates) {
+      const language = normalizeLanguageCode(candidate, isSupported);
+      if (language) return language;
+    }
+    return null;
+  };
+  const resolveLanguage = ({
+    preferredLocale,
+    userLanguage
+  }) => {
+    return normalizeLanguageCode(userLanguage, isSupported) ?? normalizeLanguageCode(preferredLocale, isSupported) ?? defaultLanguage;
+  };
+  const resolveErrorMessage2 = ({
+    errorCode,
+    errorParams,
+    preferredLocale,
+    userLanguage
+  }) => {
+    const language = resolveLanguage({ preferredLocale, userLanguage });
+    return input.translate({ language, key: errorCode, params: errorParams });
+  };
+  const normalizeErrorResponse2 = ({
+    response,
+    preferredLocale,
+    userLanguage,
+    fallbackHttpStatus
+  }) => {
+    const preNormalize = { response: { ...response }, preferredLocale, userLanguage, fallbackHttpStatus };
+    dispatchSyncHook("preErrorNormalize", preNormalize);
+    const normalized = normalizeErrorResponseCore({
+      response: preNormalize.response,
+      fallbackHttpStatus: preNormalize.fallbackHttpStatus,
+      resolveMessage: ({ errorCode, errorParams }) => resolveErrorMessage2({
+        errorCode,
+        errorParams,
+        preferredLocale: preNormalize.preferredLocale,
+        userLanguage: preNormalize.userLanguage
+      })
+    });
+    const finalized = {
+      ...normalized,
+      httpStatus: defaultHttpStatusForResponse({
+        status: "error",
+        explicitHttpStatus: normalized.httpStatus
+      })
+    };
+    const postNormalize = { normalized: finalized, preferredLocale: preNormalize.preferredLocale, userLanguage: preNormalize.userLanguage };
+    dispatchSyncHook("postErrorNormalize", postNormalize);
+    return postNormalize.normalized;
+  };
+  return { normalizeErrorResponse: normalizeErrorResponse2, resolveErrorMessage: resolveErrorMessage2, extractLanguageFromHeader: extractLanguageFromHeader2 };
+};
+var identityNormalizer = createLocalizedNormalizer({
+  translate: ({ key }) => key
+});
+var activeNormalizer = identityNormalizer;
+var normalizerRegistered = false;
+var registerLocalizedNormalizer = (normalizer) => {
+  activeNormalizer = normalizer;
+  normalizerRegistered = true;
+};
+var getLocalizedNormalizer = () => activeNormalizer;
+var isLocalizedNormalizerRegistered = () => normalizerRegistered;
+var normalizeErrorResponse = (input) => activeNormalizer.normalizeErrorResponse(input);
+var resolveErrorMessage = (input) => activeNormalizer.resolveErrorMessage(input);
+var extractLanguageFromHeader = (header) => activeNormalizer.extractLanguageFromHeader(header);
+
+// src/errorFormatterRegistry.ts
+var activeFormatter = null;
+var registerErrorFormatter = (formatter2) => {
+  activeFormatter = formatter2;
+};
+var getErrorFormatter = () => activeFormatter;
+var applyErrorFormatter = (input) => {
+  const { response, routeName, transport, userId, perRouteFormatter } = input;
+  if (response.status !== "error") return response;
+  const ctx = { routeName, transport, userId };
+  const errorEnvelope = response;
+  if (perRouteFormatter) {
+    try {
+      return perRouteFormatter(errorEnvelope, ctx);
+    } catch (error) {
+      console.error(`[errorFormatter] per-route formatter for ${routeName} threw:`, error);
+    }
+  }
+  const globalFormatter = activeFormatter;
+  if (globalFormatter) {
+    try {
+      return globalFormatter(errorEnvelope, ctx);
+    } catch (error) {
+      console.error(`[errorFormatter] global formatter threw on ${routeName}:`, error);
+      return response;
+    }
+  }
+  return response;
+};
+
+// 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/socketTypes.ts
+var _ioInstance = null;
+var setIoInstance = (io) => {
+  _ioInstance = io;
+};
+var getIoInstance = () => _ioInstance;
+
+// 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 isRegistered2 = false;
+var registerProjectConfig = (config) => {
+  activeConfig = deepMerge(DEFAULT_PROJECT_CONFIG, config);
+  isRegistered2 = true;
+};
+var getProjectConfig = () => activeConfig;
+var getProjectName = () => {
+  const fromConfig = activeConfig.session.projectName;
+  if (fromConfig && fromConfig.length > 0) return fromConfig;
+  const fromEnv = process.env.PROJECT_NAME;
+  if (fromEnv && fromEnv.length > 0) return fromEnv;
+  return "luckystack";
+};
+var isProjectConfigRegistered = () => isRegistered2;
+
+// src/runtimeMapsRegistry.ts
+var emptyApi = { apisObject: {}, functionsObject: {} };
+var emptySync = { syncObject: {}, functionsObject: {} };
+var activeProvider = {
+  getRuntimeApiMaps: () => Promise.resolve(emptyApi),
+  getRuntimeSyncMaps: () => Promise.resolve(emptySync)
+};
+var providerRegistered = false;
+var registerRuntimeMapsProvider = (provider) => {
+  activeProvider = provider;
+  providerRegistered = true;
+};
+var isRuntimeMapsProviderRegistered = () => providerRegistered;
+var getRuntimeApiMaps = async () => activeProvider.getRuntimeApiMaps();
+var getRuntimeSyncMaps = async () => activeProvider.getRuntimeSyncMaps();
+
+// 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/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/emailRegistry.ts
+var activeSender = null;
+var registry = {};
+var registerEmailSender = (sender) => {
+  activeSender = sender;
+  registry = { ...registry, default: sender };
+};
+var registerEmailSenders = (senders) => {
+  registry = { ...senders };
+  if (senders.default) {
+    activeSender = senders.default;
+  }
+};
+var getEmailSender = () => activeSender ?? registry.default ?? null;
+var getEmailSenderByName = (name) => {
+  if (registry[name]) return registry[name];
+  if (name === "default" && activeSender) return activeSender;
+  return null;
+};
+var listEmailSenderNames = () => Object.keys(registry);
+var isEmailSenderRegistered = () => activeSender !== null || Object.keys(registry).length > 0;
+
+// src/deployConfigRegistry.ts
+var DEFAULT_DEPLOY_CONFIG = {
+  resources: {}
+};
+var activeConfig2 = DEFAULT_DEPLOY_CONFIG;
+var registered = false;
+var registerDeployConfig = (config) => {
+  activeConfig2 = config;
+  registered = true;
+  return activeConfig2;
+};
+var getDeployConfig = () => activeConfig2;
+var isDeployConfigRegistered = () => registered;
+
+// src/servicesConfigRegistry.ts
+var activeServicesConfig = null;
+var registerServicesConfig = (config) => {
+  activeServicesConfig = config;
+  return activeServicesConfig;
+};
+var getServicesConfig = () => {
+  if (!activeServicesConfig) {
+    throw new Error(
+      "@luckystack/core: services config has not been registered. Call `registerServicesConfig({...})` from your `services.config.ts` (which should be imported as a side-effect during boot)."
+    );
+  }
+  return activeServicesConfig;
+};
+var isServicesConfigRegistered = () => activeServicesConfig !== null;
+
+// src/localeReloader.ts
+var activeReloader = null;
+var registerLocaleReloader = (reloader) => {
+  activeReloader = reloader;
+  return reloader;
+};
+var getLocaleReloader = () => activeReloader;
+
+// src/env.ts
+import { config as loadDotenv } from "dotenv";
+import { z } from "zod";
+var EnvSchema = z.object({
+  NODE_ENV: z.enum(["development", "production", "test"]).default("development"),
+  SERVER_IP: z.string().min(1).default("127.0.0.1"),
+  SERVER_PORT: z.string().regex(/^\d+$/).default("80"),
+  SECURE: z.enum(["true", "false"]).default("false"),
+  DNS: z.string().default(""),
+  REDIS_HOST: z.string().min(1).default("127.0.0.1"),
+  REDIS_PORT: z.string().regex(/^\d+$/).default("6379"),
+  PROJECT_NAME: z.string().min(1).default("luckystack")
+}).loose();
+var cachedEnv = null;
+var DEFAULT_ENV_FILES = [".env", ".env.local"];
+var getEnvFiles = () => {
+  const override = process.env.LUCKYSTACK_ENV_FILES;
+  if (override) {
+    const list = override.split(",").map((entry) => entry.trim()).filter(Boolean);
+    if (list.length > 0) return list;
+  }
+  return DEFAULT_ENV_FILES;
+};
+var loadEnvFiles = () => {
+  for (const [index, file] of getEnvFiles().entries()) {
+    loadDotenv({ path: file, override: index > 0 });
+  }
+};
+var applyResolvedDefaultsToProcessEnv = (resolvedEnv) => {
+  process.env.NODE_ENV = process.env.NODE_ENV ?? resolvedEnv.NODE_ENV;
+  process.env.SERVER_IP = process.env.SERVER_IP ?? resolvedEnv.SERVER_IP;
+  process.env.SERVER_PORT = process.env.SERVER_PORT ?? resolvedEnv.SERVER_PORT;
+  process.env.SECURE = process.env.SECURE ?? resolvedEnv.SECURE;
+  process.env.DNS = process.env.DNS ?? resolvedEnv.DNS;
+  process.env.REDIS_HOST = process.env.REDIS_HOST ?? resolvedEnv.REDIS_HOST;
+  process.env.REDIS_PORT = process.env.REDIS_PORT ?? resolvedEnv.REDIS_PORT;
+  process.env.PROJECT_NAME = process.env.PROJECT_NAME ?? resolvedEnv.PROJECT_NAME;
+};
+var bootstrapEnv = () => {
+  if (cachedEnv) {
+    return cachedEnv;
+  }
+  loadEnvFiles();
+  const parsed = EnvSchema.safeParse(process.env);
+  if (!parsed.success) {
+    const details = parsed.error.issues.map((issue) => `${issue.path.join(".") || "env"}: ${issue.message}`).join("; ");
+    throw new Error(`Invalid environment configuration: ${details}`);
+  }
+  cachedEnv = parsed.data;
+  applyResolvedDefaultsToProcessEnv(cachedEnv);
+  return cachedEnv;
+};
+var env = bootstrapEnv();
+var isProduction = env.NODE_ENV === "production";
+
+// src/db.ts
+import { PrismaClient } from "@prisma/client";
+
+// src/clients.ts
+var DEFAULT_CLIENT_KEY = "default";
+var prismaClients = /* @__PURE__ */ new Map();
+var redisClients = /* @__PURE__ */ new Map();
+var registerPrismaClient = (client, key = DEFAULT_CLIENT_KEY) => {
+  prismaClients.set(key, client);
+  return client;
+};
+var registerRedisClient = (client, key = DEFAULT_CLIENT_KEY) => {
+  redisClients.set(key, client);
+  return client;
+};
+var isPrismaClientRegistered = () => prismaClients.has(DEFAULT_CLIENT_KEY);
+var isRedisClientRegistered = () => redisClients.has(DEFAULT_CLIENT_KEY);
+var getPrismaClientKeys = () => [...prismaClients.keys()];
+var getRedisClientKeys = () => [...redisClients.keys()];
+var defaultPrismaResolver = null;
+var defaultRedisResolver = null;
+var setDefaultPrismaResolver = (resolver) => {
+  defaultPrismaResolver = resolver;
+};
+var setDefaultRedisResolver = (resolver) => {
+  defaultRedisResolver = resolver;
+};
+var getPrismaClientFor = (key = DEFAULT_CLIENT_KEY) => {
+  const client = prismaClients.get(key);
+  if (client) return client;
+  if (key === DEFAULT_CLIENT_KEY && defaultPrismaResolver) return defaultPrismaResolver();
+  throw new Error(
+    key === DEFAULT_CLIENT_KEY ? 'No Prisma client available. Either register one via registerPrismaClient(), or import "@luckystack/core" from a context where the default resolver was set.' : `No Prisma client registered for slot "${key}". Register one via registerPrismaClient(client, "${key}").`
+  );
+};
+var getRedisClientFor = (key = DEFAULT_CLIENT_KEY) => {
+  const client = redisClients.get(key);
+  if (client) return client;
+  if (key === DEFAULT_CLIENT_KEY && defaultRedisResolver) return defaultRedisResolver();
+  throw new Error(
+    key === DEFAULT_CLIENT_KEY ? 'No Redis client available. Either register one via registerRedisClient(), or import "@luckystack/core" from a context where the default resolver was set.' : `No Redis client registered for slot "${key}". Register one via registerRedisClient(client, "${key}").`
+  );
+};
+var getPrismaClient = () => getPrismaClientFor(DEFAULT_CLIENT_KEY);
+var getRedisClient = () => getRedisClientFor(DEFAULT_CLIENT_KEY);
+var resetClientsForTests = () => {
+  prismaClients.clear();
+  redisClients.clear();
+};
+
+// src/db.ts
+var buildDefaultPrismaClient = () => {
+  globalThis.__luckystackPrisma ??= new PrismaClient();
+  return globalThis.__luckystackPrisma;
+};
+setDefaultPrismaResolver(buildDefaultPrismaClient);
+if (process.env.NODE_ENV !== "production") {
+  buildDefaultPrismaClient();
+}
+var prisma = new Proxy({}, {
+  //? Bind methods to the real client so a CAPTURED method keeps its `this`.
+  //? Without binding, a detached call (`const q = prisma.$queryRaw; q(...)`)
+  //? runs with `this === undefined` and Prisma's internal `this`-access throws
+  //? — exactly how the `/readyz` prisma ping silently failed (it captures
+  //? `$runCommandRaw` / `$queryRaw` into a local before calling, so the ping
+  //? always threw → `prisma: false` → 503, even with the DB reachable).
+  //? Mirrors the `redis` proxy. Non-function reads (model delegates like
+  //? `prisma.user`) pass through untouched, so their methods bind to the
+  //? delegate as before.
+  get: (_target, prop, receiver) => {
+    const real = getPrismaClient();
+    const value = Reflect.get(real, prop, receiver);
+    if (typeof value !== "function") return value;
+    const fn = value;
+    return fn.bind(real);
+  },
+  has: (_target, prop) => Reflect.has(getPrismaClient(), prop),
+  ownKeys: () => Reflect.ownKeys(getPrismaClient()),
+  getOwnPropertyDescriptor: (_target, prop) => Reflect.getOwnPropertyDescriptor(getPrismaClient(), prop)
+});
+
+// src/redis.ts
+import Redis from "ioredis";
+
+// src/redisKeyFormatter.ts
+var defaultRedisKeyFormatter = (namespace, suffix) => {
+  const root = /^[-:]/.test(namespace) ? `${getProjectName()}${namespace}` : `${getProjectName()}:${namespace}`;
+  return suffix === "" ? root : `${root}:${suffix}`;
+};
+var formatter = null;
+var registerRedisKeyFormatter = (fn) => {
+  formatter = fn;
+};
+var getRedisKeyFormatter = () => formatter ?? defaultRedisKeyFormatter;
+var resetRedisKeyFormatterForTests = () => {
+  formatter = null;
+};
+var formatKey = (namespace, suffix = "") => getRedisKeyFormatter()(namespace, suffix);
+var applyStrayKeyPrefix = (key) => key.includes(":") ? key : `${getProjectName()}:${key}`;
+
+// src/redis.ts
+var cachedDefault = null;
+var MAX_REDIS_RECONNECT_ATTEMPTS = 50;
+var buildDefaultRedisClient = () => {
+  if (cachedDefault) return cachedDefault;
+  cachedDefault = new Redis({
+    host: env.REDIS_HOST,
+    port: Number.parseInt(env.REDIS_PORT, 10),
+    ...process.env.REDIS_USERNAME && { username: process.env.REDIS_USERNAME },
+    ...process.env.REDIS_PASSWORD && { password: process.env.REDIS_PASSWORD },
+    retryStrategy(times) {
+      if (times > MAX_REDIS_RECONNECT_ATTEMPTS) {
+        getLogger().error(
+          `Redis unreachable after ${String(MAX_REDIS_RECONNECT_ATTEMPTS)} reconnect attempts; giving up. Check REDIS_HOST / REDIS_PORT / credentials and that Redis is reachable.`
+        );
+        return null;
+      }
+      return Math.min(times * 50, 2e3);
+    }
+  });
+  cachedDefault.on("ready", async () => {
+    getLogger().info("Connected to Redis");
+  });
+  cachedDefault.on("error", (err) => {
+    getLogger().error("Error connecting to Redis", err);
+  });
+  return cachedDefault;
+};
+setDefaultRedisResolver(buildDefaultRedisClient);
+var getRedisConnectionOptions = () => ({
+  host: env.REDIS_HOST,
+  port: Number.parseInt(env.REDIS_PORT, 10),
+  ...process.env.REDIS_USERNAME ? { username: process.env.REDIS_USERNAME } : {},
+  ...process.env.REDIS_PASSWORD ? { password: process.env.REDIS_PASSWORD } : {}
+});
+var STRAY_PREFIX_COMMANDS = /* @__PURE__ */ new Set([
+  "get",
+  "set",
+  "setex",
+  "psetex",
+  "setnx",
+  "getset",
+  "getdel",
+  "append",
+  "strlen",
+  "expire",
+  "pexpire",
+  "expireat",
+  "pexpireat",
+  "persist",
+  "ttl",
+  "pttl",
+  "type",
+  "incr",
+  "incrby",
+  "incrbyfloat",
+  "decr",
+  "decrby",
+  "sadd",
+  "srem",
+  "smembers",
+  "scard",
+  "sismember",
+  "spop",
+  "srandmember",
+  "hget",
+  "hset",
+  "hdel",
+  "hgetall",
+  "hkeys",
+  "hvals",
+  "hexists",
+  "hincrby",
+  "hmget",
+  "hmset",
+  "lpush",
+  "rpush",
+  "lpop",
+  "rpop",
+  "llen",
+  "lrange",
+  "lrem",
+  "zadd",
+  "zrem",
+  "zscore",
+  "zrange",
+  "zrank",
+  "zcard",
+  "getbit",
+  "setbit",
+  "bitcount"
+]);
+var redisProxy = new Proxy({}, {
+  get: (_target, prop, receiver) => {
+    const real = getRedisClient();
+    const value = Reflect.get(real, prop, receiver);
+    if (typeof value !== "function") return value;
+    const fn = value;
+    if (typeof prop === "string" && STRAY_PREFIX_COMMANDS.has(prop.toLowerCase())) {
+      return (...args) => {
+        if (args.length > 0 && typeof args[0] === "string") {
+          args[0] = applyStrayKeyPrefix(args[0]);
+        }
+        return fn.apply(real, args);
+      };
+    }
+    return fn.bind(real);
+  },
+  has: (_target, prop) => Reflect.has(getRedisClient(), prop)
+});
+var redis = redisProxy;
+
+// src/lease.ts
+import { randomBytes } from "crypto";
+var leaseKey = (name) => formatKey("lease", name);
+var RENEW_SCRIPT = `
+if redis.call('get', KEYS[1]) == ARGV[1] then
+  return redis.call('pexpire', KEYS[1], ARGV[2])
+else
+  return 0
+end
+`;
+var RELEASE_SCRIPT = `
+if redis.call('get', KEYS[1]) == ARGV[1] then
+  return redis.call('del', KEYS[1])
+else
+  return 0
+end
+`;
+var acquireLease = async (name, ttlMs) => {
+  const token = randomBytes(16).toString("hex");
+  const [error, result] = await tryCatch(
+    async () => redis.set(leaseKey(name), token, "PX", ttlMs, "NX")
+  );
+  if (error) return null;
+  return result === "OK" ? token : null;
+};
+var renewLease = async (name, token, ttlMs) => {
+  const [error, result] = await tryCatch(
+    async () => redis.eval(RENEW_SCRIPT, 1, leaseKey(name), token, String(ttlMs))
+  );
+  if (error) return false;
+  return result === 1;
+};
+var releaseLease = async (name, token) => {
+  const [error, result] = await tryCatch(
+    async () => redis.eval(RELEASE_SCRIPT, 1, leaseKey(name), token)
+  );
+  if (error) return false;
+  return result === 1;
+};
+
+// src/socketRedisAdapter.ts
+import { createAdapter } from "@socket.io/redis-adapter";
+var attachSocketRedisAdapter = (io) => {
+  const pubClient = redis.duplicate();
+  const subClient = redis.duplicate();
+  pubClient.on("error", (err) => {
+    getLogger().error("[socket-redis-adapter] pub client error", err);
+  });
+  subClient.on("error", (err) => {
+    getLogger().error("[socket-redis-adapter] sub client error", err);
+  });
+  io.adapter(createAdapter(pubClient, subClient));
+};
+
+// src/bootUuid.ts
+import { randomUUID } from "crypto";
+var BOOT_KEY_PREFIX = "luckystack:boot:";
+var DEFAULT_BOOT_KEY_TTL_SECONDS = 3600;
+var getBootKeyTtlSeconds = () => getDeployConfig().routing?.bootKeyTtlSeconds ?? DEFAULT_BOOT_KEY_TTL_SECONDS;
+var resolveEnvKey = () => {
+  return process.env.LUCKYSTACK_ENV ?? process.env.NODE_ENV ?? "development";
+};
+var writeBootUuid = async (envKey) => {
+  const key = envKey ?? resolveEnvKey();
+  const uuid = randomUUID();
+  await redis.set(`${BOOT_KEY_PREFIX}${key}`, uuid, "EX", getBootKeyTtlSeconds());
+  return uuid;
+};
+var readBootUuid = async (envKey) => {
+  const key = envKey ?? resolveEnvKey();
+  return redis.get(`${BOOT_KEY_PREFIX}${key}`);
+};
+
+// src/synchronizedEnvHashes.ts
+import { createHash } from "crypto";
+var hashValue = (value) => {
+  return createHash("sha256").update(value).digest("hex");
+};
+var collectSynchronizedEnvKeys = () => {
+  const keys = /* @__PURE__ */ new Set();
+  for (const resource of Object.values(getDeployConfig().resources)) {
+    for (const key of resource.synchronizedEnvKeys ?? []) {
+      keys.add(key);
+    }
+  }
+  return [...keys].toSorted();
+};
+var computeSynchronizedEnvHashes = () => {
+  const keys = collectSynchronizedEnvKeys();
+  const out = {};
+  for (const key of keys) {
+    const value = process.env[key];
+    out[key] = value === void 0 ? null : hashValue(value);
+  }
+  return out;
+};
+var hashSynchronizedValue = (value) => hashValue(value);
+
+// src/consoleLog.ts
+var COLORS = {
+  black: "\x1B[30m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  reset: "\x1B[0m"
+};
+var FILE_NAME_REGEX = /[\\/]([^\\/]+)$/;
+var extractFrameLabel = (frame) => {
+  let lineInfo = frame.slice(frame.indexOf("(") + 1, frame.lastIndexOf(")"));
+  if (lineInfo === "") lineInfo = frame;
+  const match = FILE_NAME_REGEX.exec(lineInfo);
+  const fileName = match?.[1] ?? lineInfo;
+  return fileName.replace(/:\d+(?::\d+)?$/, "");
+};
+var initConsolelog = () => {
+  const originalLog = console.log;
+  console.log = (...args) => {
+    const stackLines = new Error("console.log trace").stack?.split("\n") ?? [];
+    const frame = stackLines.slice(1).find((line) => {
+      const trimmed = line.trim();
+      return trimmed.length > 0 && !trimmed.includes("consoleLog.ts") && !trimmed.includes("loggerRegistry.ts");
+    })?.trim();
+    if (!frame) {
+      originalLog(...args);
+      return;
+    }
+    const extractedInfo = extractFrameLabel(frame);
+    let colorCode = COLORS.white;
+    for (const key of Object.keys(COLORS)) {
+      const index = args.indexOf(key);
+      if (index !== -1) {
+        colorCode = COLORS[key];
+        args.splice(index, 1);
+        break;
+      }
+    }
+    if (typeof args[0] === "object") {
+      originalLog(`${colorCode}${extractedInfo}${COLORS.reset}`);
+      originalLog(...args);
+    } else {
+      originalLog(`${colorCode}${extractedInfo} -- ${args.join(" ")}${COLORS.reset}`);
+    }
+  };
+};
+
+// src/redactedLogKeys.ts
+var DEFAULT_REDACTED_LOG_KEYS = [
+  "password",
+  "confirmpassword",
+  "token",
+  "newtoken",
+  "authorization",
+  "cookie",
+  "set-cookie"
+];
+var redactedKeys = new Set(DEFAULT_REDACTED_LOG_KEYS.map((key) => key.toLowerCase()));
+var registerRedactedLogKeys = (keys) => {
+  for (const key of keys) {
+    redactedKeys.add(key.toLowerCase());
+  }
+};
+var getRedactedLogKeys = () => [...redactedKeys];
+var isRedactedLogKey = (key) => {
+  return redactedKeys.has(key.toLowerCase());
+};
+var resetRedactedLogKeysForTests = () => {
+  redactedKeys.clear();
+  for (const key of DEFAULT_REDACTED_LOG_KEYS) {
+    redactedKeys.add(key.toLowerCase());
+  }
+};
+
+// src/cookies.ts
+var escapeRegExp = (value) => {
+  return value.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
+};
+var getCookieValue = (cookieHeader, cookieName) => {
+  if (!cookieHeader || !cookieName) {
+    return null;
+  }
+  const safeCookieName = escapeRegExp(cookieName);
+  const cookieRegex = new RegExp(String.raw`(?:^|;\s*)${safeCookieName}=([^;]*)`);
+  const match = cookieHeader.match(cookieRegex);
+  const rawValue = match?.[1];
+  if (!rawValue) {
+    return null;
+  }
+  try {
+    return decodeURIComponent(rawValue);
+  } catch {
+    return rawValue;
+  }
+};
+var hasCookie = (cookieHeader, cookieName) => {
+  return getCookieValue(cookieHeader, cookieName) !== null;
+};
+
+// src/httpApiUtils.ts
+var inferHttpMethod = (apiName) => {
+  const nameParts = apiName.split("/");
+  const lastPart = nameParts.at(-1)?.toLowerCase() ?? "";
+  const methodName = /^v\d+$/.test(lastPart) ? (nameParts.at(-2) ?? "").toLowerCase() : lastPart;
+  if (methodName.startsWith("get") || methodName.startsWith("fetch") || methodName.startsWith("list")) {
+    return "GET";
+  }
+  if (methodName.startsWith("delete") || methodName.startsWith("remove")) {
+    return "DELETE";
+  }
+  if (methodName.startsWith("update") || methodName.startsWith("edit") || methodName.startsWith("patch")) {
+    return "PUT";
+  }
+  return "POST";
+};
+var getEffectiveHttpMethod = (apiConfig, apiName) => {
+  return apiConfig.httpMethod ?? inferHttpMethod(apiName);
+};
+var isMethodAllowed = (requestMethod, allowedMethod) => {
+  return requestMethod === allowedMethod || requestMethod === "OPTIONS";
+};
+
+// src/paths.ts
+import path from "path";
+import fs from "fs";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var isWorkspaceRoot = (candidate) => {
+  return fs.existsSync(path.join(candidate, "package.json")) && (fs.existsSync(path.join(candidate, "tsconfig.json")) || fs.existsSync(path.join(candidate, "tsconfig.server.json")));
+};
+var findWorkspaceRoot = (startDir) => {
+  let current = path.resolve(startDir);
+  while (true) {
+    if (isWorkspaceRoot(current)) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+};
+var ROOT_DIR = findWorkspaceRoot(process.cwd()) ?? findWorkspaceRoot(__dirname) ?? process.cwd();
+var resolveAgainstRoot = (relative) => path.isAbsolute(relative) ? relative : path.join(ROOT_DIR, relative);
+var getSrcDir = () => resolveAgainstRoot(getProjectConfig().paths.srcDir);
+var getServerDir = () => resolveAgainstRoot(getProjectConfig().paths.serverDir);
+var getSharedDir = () => resolveAgainstRoot(getProjectConfig().paths.sharedDir);
+var getUploadsDir = () => resolveAgainstRoot(getProjectConfig().paths.uploadsDir);
+var getPublicDir = () => resolveAgainstRoot(getProjectConfig().paths.publicDir);
+var getServerFunctionDirs = () => {
+  const paths = getProjectConfig().paths;
+  const arrayConfig = paths.serverFunctionDirs;
+  if (Array.isArray(arrayConfig) && arrayConfig.length > 0) {
+    return arrayConfig.map((p) => resolveAgainstRoot(p));
+  }
+  const legacySingular = paths.serverFunctionsDir;
+  if (typeof legacySingular === "string" && legacySingular.length > 0) {
+    return [resolveAgainstRoot(legacySingular)];
+  }
+  return [];
+};
+var getServerFunctionsDir = () => {
+  const dirs = getServerFunctionDirs();
+  return dirs[0] ?? resolveAgainstRoot("functions");
+};
+var getGeneratedSocketTypesPath = () => resolveAgainstRoot(getProjectConfig().paths.generatedSocketTypes);
+var getGeneratedApiSchemasPath = () => resolveAgainstRoot(getProjectConfig().paths.generatedApiSchemas);
+var getGeneratedApiDocsPath = () => resolveAgainstRoot(getProjectConfig().paths.generatedApiDocs);
+var SRC_DIR = path.join(ROOT_DIR, "src");
+var SERVER_DIR = path.join(ROOT_DIR, "server");
+var SHARED_DIR = path.join(ROOT_DIR, "shared");
+var UPLOADS_DIR = path.join(ROOT_DIR, "uploads");
+var PUBLIC_DIR = path.join(ROOT_DIR, "public");
+var SERVER_FUNCTIONS_DIR = path.join(SERVER_DIR, "functions");
+var GENERATED_SOCKET_TYPES_PATH = path.join(SRC_DIR, "_sockets", "apiTypes.generated.ts");
+var GENERATED_API_SCHEMAS_PATH = path.join(SRC_DIR, "_sockets", "apiInputSchemas.generated.ts");
+var GENERATED_API_DOCS_PATH = path.join(SRC_DIR, "docs", "apiDocs.generated.json");
+var TSCONFIG_ALIAS_FILES = ["tsconfig.server.json", "tsconfig.client.json"];
+var resolveFromRoot = (...segments) => path.join(ROOT_DIR, ...segments);
+
+// src/socketMiddlewareRegistry.ts
+var middlewares = [];
+var registerSocketMiddleware = (mw) => {
+  middlewares.push(mw);
+};
+var getSocketMiddlewares = () => middlewares;
+var clearSocketMiddlewares = () => {
+  middlewares.length = 0;
+};
+var applySocketMiddlewares = (io) => {
+  for (const mw of middlewares) {
+    io.use(mw);
+  }
+};
+
+// 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 registerCsrfConfig = (input) => {
+  active = {
+    ...active,
+    ...input,
+    cookieOptions: { ...active.cookieOptions, ...input.cookieOptions }
+  };
+};
+var getCsrfConfig = () => active;
+var resetCsrfConfigForTests = () => {
+  active = DEFAULT_CSRF_CONFIG;
+};
+
+// src/serveAvatars.ts
+import path2 from "path";
+import { access } from "fs/promises";
+import fs2 from "fs";
+
+// src/avatarConfig.ts
+var DEFAULT_AVATAR_CONFIG = {
+  formats: [{ extension: "webp", contentType: "image/webp" }],
+  cacheControl: "public, max-age=86400"
+};
+var activeConfig3 = DEFAULT_AVATAR_CONFIG;
+var registerAvatarConfig = (config) => {
+  activeConfig3 = {
+    formats: config.formats?.length ? config.formats : DEFAULT_AVATAR_CONFIG.formats,
+    cacheControl: config.cacheControl ?? DEFAULT_AVATAR_CONFIG.cacheControl
+  };
+};
+var getAvatarConfig = () => activeConfig3;
+
+// src/serveAvatars.ts
+var FILE_ID_REGEX = /^[A-Za-z0-9_-]{1,128}$/;
+var serveAvatar = async ({
+  routePath,
+  res
+}) => {
+  const uploadsFolder = getUploadsDir();
+  const fileId = path2.basename(routePath, path2.extname(routePath));
+  if (!fileId || !FILE_ID_REGEX.test(fileId)) {
+    res.writeHead(404, { "Content-Type": "text/plain" });
+    res.end("File not found");
+    return;
+  }
+  const { formats, cacheControl } = getAvatarConfig();
+  for (const { extension, contentType } of formats) {
+    const filePath = path2.join(uploadsFolder, `${fileId}.${extension}`);
+    const [accessError] = await tryCatch(() => access(filePath));
+    if (accessError) continue;
+    res.writeHead(200, {
+      "Content-Type": contentType,
+      "Cache-Control": cacheControl
+    });
+    fs2.createReadStream(filePath).pipe(res);
+    return;
+  }
+  getLogger().debug("avatar: file not found", { routePath, fileId });
+  res.writeHead(404, { "Content-Type": "text/plain" });
+  res.end("File not found");
+};
+
+// src/processUpload.ts
+var processUpload = async (input) => {
+  const uploadKind = input.uploadKind ?? "avatar";
+  const startSignal = await dispatchHook("onUploadStart", {
+    userId: input.userId,
+    contentType: input.contentType,
+    sizeBytes: input.buffer.byteLength,
+    uploadKind
+  });
+  if (startSignal.stopped) {
+    return { status: "rejected", errorCode: startSignal.signal.errorCode };
+  }
+  const [error, finalSize] = await tryCatch(() => input.encodeAndSave(input.buffer));
+  if (error) {
+    return { status: "error", reason: error.message || "encode-failed", cause: error };
+  }
+  const sizeBytes = finalSize ?? input.buffer.byteLength;
+  await dispatchHook("onUploadComplete", {
+    userId: input.userId,
+    fileName: input.fileName,
+    sizeBytes,
+    uploadKind
+  });
+  return { status: "success", sizeBytes };
+};
+
+// src/bindAddress.ts
+var registered2 = null;
+var registerBindAddress = (address) => {
+  registered2 = address;
+};
+var getBindAddress = () => {
+  if (registered2) {
+    return { ip: registered2.ip, port: String(registered2.port) };
+  }
+  return {
+    ip: process.env.SERVER_IP ?? "127.0.0.1",
+    port: process.env.SERVER_PORT ?? ""
+  };
+};
+
+// src/getParams.ts
+async function getParams({ method, req, res: _res, queryString }) {
+  if (method == "GET") {
+    return Object.fromEntries(new URLSearchParams(queryString || ""));
+  }
+  return new Promise((resolve, reject) => {
+    const contentType = req.headers["content-type"] || "";
+    const contentLengthHeader = req.headers["content-length"];
+    const declaredLength = typeof contentLengthHeader === "string" ? Number(contentLengthHeader) : Number.NaN;
+    const maxBodyBytes = getProjectConfig().http.requestBodyMaxBytes;
+    if (Number.isFinite(declaredLength) && declaredLength > maxBodyBytes) {
+      _res.setHeader("Content-Type", "application/json");
+      _res.writeHead(413);
+      _res.end(JSON.stringify({
+        status: "error",
+        httpStatus: 413,
+        message: "api.payloadTooLarge",
+        errorCode: "api.payloadTooLarge"
+      }));
+      resolve(null);
+      return;
+    }
+    let body = "";
+    let bodySize = 0;
+    req.on("data", (chunk) => {
+      bodySize += chunk.length;
+      if (bodySize > maxBodyBytes) {
+        _res.setHeader("Content-Type", "application/json");
+        _res.writeHead(413);
+        _res.end(JSON.stringify({
+          status: "error",
+          httpStatus: 413,
+          message: "api.payloadTooLarge",
+          errorCode: "api.payloadTooLarge"
+        }));
+        req.destroy();
+        resolve(null);
+        return;
+      }
+      body += chunk.toString();
+    });
+    req.on("end", async () => {
+      if (contentType.startsWith("application/x-www-form-urlencoded")) {
+        const parseData = () => {
+          const data = new URLSearchParams(body);
+          return Object.fromEntries(data);
+        };
+        const [, response] = await tryCatch(parseData);
+        if (response) {
+          resolve(response);
+          return;
+        }
+        _res.setHeader("Content-Type", "application/json");
+        _res.writeHead(400);
+        _res.end(JSON.stringify({
+          status: "error",
+          httpStatus: 400,
+          message: "api.invalidRequestFormat",
+          errorCode: "api.invalidRequestFormat"
+        }));
+        resolve(null);
+        return;
+      }
+      if (contentType.startsWith("application/json")) {
+        const parseData = () => {
+          return JSON.parse(body || "{}");
+        };
+        const [, response] = await tryCatch(parseData);
+        if (response && typeof response === "object" && !Array.isArray(response)) {
+          resolve(response);
+          return;
+        }
+        _res.setHeader("Content-Type", "application/json");
+        _res.writeHead(400);
+        _res.end(JSON.stringify({
+          status: "error",
+          httpStatus: 400,
+          message: "api.invalidRequestFormat",
+          errorCode: "api.invalidRequestFormat"
+        }));
+        resolve(null);
+        return;
+      }
+      _res.setHeader("Content-Type", "application/json");
+      _res.writeHead(415);
+      _res.end(JSON.stringify({
+        status: "error",
+        httpStatus: 415,
+        message: "api.unsupportedMediaType",
+        errorCode: "api.unsupportedMediaType"
+      }));
+      resolve(null);
+    });
+    req.on("error", (error) => {
+      reject(error);
+    });
+  });
+}
+
+// src/extractToken.ts
+var extractTokenFromSocket = (socket2) => {
+  const cookie = socket2.handshake.headers.cookie;
+  const sessionToken = typeof socket2.handshake.auth?.token === "string" ? socket2.handshake.auth.token : null;
+  const cookieToken = getCookieValue(cookie, getProjectConfig().http.sessionCookieName);
+  if (getProjectConfig().session.basedToken) {
+    return sessionToken ?? cookieToken;
+  }
+  return cookieToken ?? sessionToken;
+};
+
+// src/extractTokenFromRequest.ts
+var extractTokenFromRequest = (req) => {
+  const authHeader = req.headers.authorization;
+  const bearerToken = authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : null;
+  const cookieToken = getCookieValue(req.headers.cookie, getProjectConfig().http.sessionCookieName);
+  if (getProjectConfig().session.basedToken) {
+    return bearerToken ?? cookieToken;
+  }
+  return cookieToken ?? bearerToken;
+};
+
+// src/validateRequest.ts
+var isFalsy = (value) => {
+  return value === false || value === 0 || value === 0n || value === "" || value === null || value === void 0 || typeof value === "number" && Number.isNaN(value);
+};
+var validateRequest = ({
+  auth,
+  user
+}) => {
+  if (!auth.additional) {
+    return { status: "success" };
+  }
+  const forbid = (key) => ({
+    status: "error",
+    errorCode: "auth.forbidden",
+    errorParams: [{ key: "key", value: key }],
+    httpStatus: 403
+  });
+  for (const condition of auth.additional) {
+    if (!(condition.key in user)) {
+      return {
+        status: "error",
+        errorCode: "auth.invalidCondition",
+        errorParams: [{ key: "key", value: condition.key }],
+        httpStatus: 500
+      };
+    }
+    const val = user[condition.key];
+    const isNullish = val === null || val === void 0;
+    if (typeof condition.nullish === "boolean" && condition.nullish !== isNullish) {
+      return forbid(condition.key);
+    }
+    if (condition.type && !isNullish && typeof val !== condition.type) {
+      return forbid(condition.key);
+    }
+    if ("value" in condition && val !== condition.value) {
+      return forbid(condition.key);
+    }
+    if (typeof condition.mustBeFalsy === "boolean" && condition.mustBeFalsy !== isFalsy(val)) {
+      return forbid(condition.key);
+    }
+  }
+  return { status: "success" };
+};
+
+// src/rateLimiter.ts
+var rateLimitStore = /* @__PURE__ */ new Map();
+var getRedisPrefix = () => formatKey(`:${getProjectConfig().rateLimiting.redisKeyPrefix}`, "");
+var isRedisMode = () => getProjectConfig().rateLimiting.store === "redis";
+var isRateLimitingEnabled = () => getProjectConfig().rateLimiting.enabled;
+var buildAllowedResult = (limit) => ({
+  allowed: true,
+  remaining: Math.max(0, limit),
+  resetIn: 0
+});
+var redisFallbackLogged = false;
+var RATE_LIMIT_INCREMENT_SCRIPT = `
+local current = redis.call('INCR', KEYS[1])
+if current == 1 then
+  redis.call('PEXPIRE', KEYS[1], ARGV[1])
+end
+local ttl = redis.call('PTTL', KEYS[1])
+return { current, ttl }
+`;
+var normalizeWindowMs = (windowMs) => {
+  if (!Number.isFinite(windowMs) || windowMs <= 0) {
+    return getProjectConfig().rateLimiting.windowMs;
+  }
+  return windowMs;
+};
+var getRedisRateLimitKey = (key) => `${getRedisPrefix()}:${key}`;
+var checkRateLimitInMemory = ({
+  key,
+  limit,
+  windowMs = 6e4
+}) => {
+  const safeWindowMs = normalizeWindowMs(windowMs);
+  const now = Date.now();
+  const entry = rateLimitStore.get(key);
+  if (!entry || entry.resetAt < now) {
+    rateLimitStore.set(key, { count: 1, resetAt: now + safeWindowMs });
+    return { allowed: true, remaining: limit - 1, resetIn: Math.ceil(safeWindowMs / 1e3) };
+  }
+  entry.count += 1;
+  return {
+    allowed: entry.count <= limit,
+    remaining: Math.max(0, limit - entry.count),
+    resetIn: Math.ceil((entry.resetAt - now) / 1e3)
+  };
+};
+var checkRateLimitInRedis = async ({
+  key,
+  limit,
+  windowMs = 6e4
+}) => {
+  const safeWindowMs = normalizeWindowMs(windowMs);
+  const redisKey = getRedisRateLimitKey(key);
+  const [evalError, evalResponse] = await tryCatch(
+    async () => await redis.eval(RATE_LIMIT_INCREMENT_SCRIPT, 1, redisKey, String(safeWindowMs))
+  );
+  if (evalError || !Array.isArray(evalResponse) || evalResponse.length < 2) {
+    return null;
+  }
+  const requestCount = Number(evalResponse[0]);
+  const ttlMs = Number(evalResponse[1]);
+  const safeCount = Number.isFinite(requestCount) ? requestCount : 1;
+  const safeTtlMs = Number.isFinite(ttlMs) && ttlMs > 0 ? ttlMs : safeWindowMs;
+  return {
+    allowed: safeCount <= limit,
+    remaining: Math.max(0, limit - safeCount),
+    resetIn: Math.ceil(safeTtlMs / 1e3)
+  };
+};
+var getRateLimitStatusInMemory = (key, limit) => {
+  const now = Date.now();
+  const entry = rateLimitStore.get(key);
+  if (!entry || entry.resetAt < now) {
+    return { allowed: true, remaining: limit, resetIn: 0 };
+  }
+  return {
+    allowed: entry.count < limit,
+    remaining: Math.max(0, limit - entry.count),
+    resetIn: Math.ceil((entry.resetAt - now) / 1e3)
+  };
+};
+var getRateLimitStatusInRedis = async (key, limit) => {
+  const redisKey = getRedisRateLimitKey(key);
+  const [txError, txResponse] = await tryCatch(
+    async () => await redis.multi().get(redisKey).pttl(redisKey).exec()
+  );
+  if (txError || !txResponse || txResponse.length < 2) return null;
+  const getResult = txResponse[0];
+  const ttlResult = txResponse[1];
+  if (!getResult || !ttlResult || getResult[0] || ttlResult[0]) return null;
+  const currentCount = Number(getResult[1] ?? 0);
+  const ttlMs = Number(ttlResult[1] ?? 0);
+  if (currentCount <= 0 || ttlMs <= 0) {
+    return { allowed: true, remaining: limit, resetIn: 0 };
+  }
+  return {
+    allowed: currentCount < limit,
+    remaining: Math.max(0, limit - currentCount),
+    resetIn: Math.ceil(ttlMs / 1e3)
+  };
+};
+var logRedisFallback = () => {
+  if (redisFallbackLogged) return;
+  redisFallbackLogged = true;
+  getLogger().warn("[RateLimiter] Redis mode unavailable, falling back to in-memory mode");
+};
+var defaultRateLimitStrategy = {
+  name: "default-memory-redis",
+  async check(params) {
+    if (!isRateLimitingEnabled()) return buildAllowedResult(params.limit);
+    if (isRedisMode()) {
+      const redisResult = await checkRateLimitInRedis(params);
+      if (redisResult) return redisResult;
+      logRedisFallback();
+    }
+    return checkRateLimitInMemory(params);
+  },
+  async getStatus(key, limit) {
+    if (!isRateLimitingEnabled()) return buildAllowedResult(limit);
+    if (isRedisMode()) {
+      const redisResult = await getRateLimitStatusInRedis(key, limit);
+      if (redisResult) return redisResult;
+      logRedisFallback();
+    }
+    return getRateLimitStatusInMemory(key, limit);
+  },
+  async clear(key) {
+    if (isRedisMode()) {
+      await tryCatch(async () => await redis.del(getRedisRateLimitKey(key)));
+    }
+    rateLimitStore.delete(key);
+  },
+  async clearAll() {
+    if (isRedisMode()) {
+      let cursor = "0";
+      do {
+        const [scanError, scanResponse] = await tryCatch(
+          async () => await redis.scan(cursor, "MATCH", `${getRedisPrefix()}:*`, "COUNT", 100)
+        );
+        if (scanError || !scanResponse) break;
+        cursor = scanResponse[0];
+        const keys = scanResponse[1];
+        if (keys.length > 0) {
+          await tryCatch(async () => await redis.del(...keys));
+        }
+      } while (cursor !== "0");
+    }
+    rateLimitStore.clear();
+  }
+};
+var activeStrategy = defaultRateLimitStrategy;
+var registerRateLimitStrategy = (strategy) => {
+  activeStrategy = strategy;
+  getLogger().debug(`[RateLimiter] active strategy \u2192 ${strategy.name}`);
+};
+var getRateLimitStrategy = () => activeStrategy;
+var checkRateLimit = async (params) => activeStrategy.check(params);
+var getRateLimitStatus = async (key, limit) => activeStrategy.getStatus(key, limit);
+var clearRateLimit = async (key) => activeStrategy.clear(key);
+var clearAllRateLimits = async () => activeStrategy.clearAll();
+var scheduleCleanup = () => {
+  const intervalMs = getProjectConfig().rateLimiting.cleanupIntervalMs;
+  const timer = setTimeout(() => {
+    const now = Date.now();
+    let cleaned = 0;
+    for (const [key, entry] of rateLimitStore) {
+      if (entry.resetAt < now) {
+        rateLimitStore.delete(key);
+        cleaned++;
+      }
+    }
+    if (cleaned > 0) {
+      getLogger().debug(`[RateLimiter] Cleaned ${String(cleaned)} expired entries`);
+    }
+    scheduleCleanup();
+  }, intervalMs);
+  timer.unref();
+};
+scheduleCleanup();
+
+// src/runtimeTypeValidation.ts
+var splitTopLevel = (value, splitter) => {
+  const items = [];
+  let depthParen = 0;
+  let depthBrace = 0;
+  let depthBracket = 0;
+  let token = "";
+  for (const char of value) {
+    if (char === "(") depthParen += 1;
+    if (char === ")") depthParen -= 1;
+    if (char === "{") depthBrace += 1;
+    if (char === "}") depthBrace -= 1;
+    if (char === "[") depthBracket += 1;
+    if (char === "]") depthBracket -= 1;
+    if (char === splitter && depthParen === 0 && depthBrace === 0 && depthBracket === 0) {
+      items.push(token.trim());
+      token = "";
+      continue;
+    }
+    token += char;
+  }
+  if (token.trim()) items.push(token.trim());
+  return items;
+};
+var parseObjectFields = (typeText) => {
+  const clean = typeText.trim();
+  if (!clean.startsWith("{") || !clean.endsWith("}")) {
+    return { fields: [], indexSignatures: [] };
+  }
+  const inner = clean.slice(1, -1);
+  const fields = [];
+  const indexSignatures = [];
+  let part = "";
+  let depth = 0;
+  for (const char of inner) {
+    if (char === "{" || char === "[" || char === "(" || char === "<") depth += 1;
+    if (char === "}" || char === "]" || char === ")" || char === ">") depth -= 1;
+    if (char === ";" && depth === 0) {
+      const trimmed = part.trim();
+      if (trimmed) {
+        const fieldMatch = /^("|')?[A-Za-z_][A-Za-z0-9_]*("|')?(\?)?\s*:\s*([\s\S]+)$/.exec(trimmed);
+        if (fieldMatch) {
+          const keyMatch = /^("|')?[A-Za-z_][A-Za-z0-9_]*("|')?/.exec(trimmed);
+          const rawKey = keyMatch?.[0] ?? "";
+          fields.push({
+            key: rawKey.replaceAll(/^['"]|['"]$/g, ""),
+            optional: Boolean(fieldMatch[3]),
+            type: (fieldMatch[4] ?? "").trim()
+          });
+        } else {
+          const indexMatch = /^\[\s*([A-Za-z_][A-Za-z0-9_]*)\s*:\s*([^\]]+)\]\s*:\s*([\s\S]+)$/.exec(trimmed);
+          if (indexMatch) {
+            indexSignatures.push({
+              keyName: (indexMatch[1] ?? "").trim(),
+              keyType: (indexMatch[2] ?? "").trim(),
+              type: (indexMatch[3] ?? "").trim()
+            });
+          }
+        }
+      }
+      part = "";
+      continue;
+    }
+    part += char;
+  }
+  const final = part.trim();
+  if (final) {
+    const fieldMatch = /^("|')?[A-Za-z_][A-Za-z0-9_]*("|')?(\?)?\s*:\s*([\s\S]+)$/.exec(final);
+    if (fieldMatch) {
+      const keyMatch = /^("|')?[A-Za-z_][A-Za-z0-9_]*("|')?/.exec(final);
+      const rawKey = keyMatch?.[0] ?? "";
+      fields.push({
+        key: rawKey.replaceAll(/^['"]|['"]$/g, ""),
+        optional: Boolean(fieldMatch[3]),
+        type: (fieldMatch[4] ?? "").trim()
+      });
+    } else {
+      const indexMatch = /^\[\s*([A-Za-z_][A-Za-z0-9_]*)\s*:\s*([^\]]+)\]\s*:\s*([\s\S]+)$/.exec(final);
+      if (indexMatch) {
+        indexSignatures.push({
+          keyName: (indexMatch[1] ?? "").trim(),
+          keyType: (indexMatch[2] ?? "").trim(),
+          type: (indexMatch[3] ?? "").trim()
+        });
+      }
+    }
+  }
+  return { fields, indexSignatures };
+};
+var matchesIndexKeyType = ({ keyType, key }) => {
+  const normalized = keyType.trim();
+  if (normalized === "string") return true;
+  if (normalized === "number") return /^-?\d+(\.\d+)?$/.test(key);
+  if (normalized.includes("|")) {
+    const parts = splitTopLevel(normalized, "|").map((part) => part.trim());
+    return parts.some((part) => matchesIndexKeyType({ keyType: part, key }));
+  }
+  if (normalized.startsWith("'") && normalized.endsWith("'") || normalized.startsWith('"') && normalized.endsWith('"')) {
+    return key === normalized.slice(1, -1);
+  }
+  return false;
+};
+var isPrimitiveMatch = (type, value) => {
+  if (type === "string") return typeof value === "string";
+  if (type === "number") return typeof value === "number" && Number.isFinite(value);
+  if (type === "boolean") return typeof value === "boolean";
+  if (type === "true") return value === true;
+  if (type === "false") return value === false;
+  if (type === "null") return value === null;
+  if (type === "undefined") return value === void 0;
+  if (type === "Date") return typeof value === "string" || value instanceof Date;
+  return false;
+};
+var isPrimitiveType = (type) => {
+  return ["string", "number", "boolean", "true", "false", "null", "undefined", "Date"].includes(type);
+};
+var validateType = (typeText, value, path3) => {
+  const type = typeText.trim();
+  if (type.startsWith("__RUNTIME_UNRESOLVED__::")) {
+    const unresolvedMessage = type.replace("__RUNTIME_UNRESOLVED__::", "").trim();
+    return { status: "error", message: `${path3}: ${unresolvedMessage}` };
+  }
+  if (type.startsWith("(") && type.endsWith(")")) {
+    return validateType(type.slice(1, -1), value, path3);
+  }
+  if (type.includes("|")) {
+    const unionParts = splitTopLevel(type, "|").filter(Boolean);
+    if (unionParts.length > 1) {
+      for (const unionType of unionParts) {
+        const result = validateType(unionType, value, path3);
+        if (result.status === "success") return result;
+      }
+      return { status: "error", message: `${path3} does not match union type ${type}` };
+    }
+  }
+  if (type.includes("&")) {
+    const intersectionParts = splitTopLevel(type, "&").filter(Boolean);
+    if (intersectionParts.length > 1) {
+      for (const intersectionType of intersectionParts) {
+        const result = validateType(intersectionType, value, path3);
+        if (result.status === "error") return result;
+      }
+      return { status: "success" };
+    }
+  }
+  if (type.endsWith("[]")) {
+    if (!Array.isArray(value)) {
+      return { status: "error", message: `${path3} should be an array` };
+    }
+    const itemType = type.slice(0, -2).trim();
+    if (itemType === type) {
+      return { status: "success" };
+    }
+    for (const [index, element] of value.entries()) {
+      const result = validateType(itemType, element, `${path3}[${String(index)}]`);
+      if (result.status === "error") return result;
+    }
+    return { status: "success" };
+  }
+  if (type.startsWith("'") && type.endsWith("'") || type.startsWith('"') && type.endsWith('"')) {
+    const literal = type.slice(1, -1);
+    return value === literal ? { status: "success" } : { status: "error", message: `${path3} should equal ${literal}` };
+  }
+  if (isPrimitiveMatch(type, value)) {
+    return { status: "success" };
+  }
+  if (isPrimitiveType(type)) {
+    const expectedType = type === "Date" ? "Date (ISO string or Date)" : type;
+    return { status: "error", message: `${path3} should be ${expectedType}` };
+  }
+  if (type === "any" || type === "unknown") {
+    return { status: "success" };
+  }
+  if (/^Record<.+>$/.test(type)) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      return { status: "success" };
+    }
+    return { status: "error", message: `${path3} should be an object` };
+  }
+  if (type.startsWith("{") && type.endsWith("}")) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      return { status: "error", message: `${path3} should be an object` };
+    }
+    const { fields, indexSignatures } = parseObjectFields(type);
+    const input = value;
+    for (const field of fields) {
+      const fieldValue = input[field.key];
+      if (fieldValue === void 0) {
+        if (field.optional) continue;
+        return { status: "error", message: `${path3}.${field.key} is required` };
+      }
+      const result = validateType(field.type, fieldValue, `${path3}.${field.key}`);
+      if (result.status === "error") return result;
+    }
+    const allowedKeys = new Set(fields.map((field) => field.key));
+    for (const key of Object.keys(input)) {
+      if (allowedKeys.has(key)) {
+        continue;
+      }
+      if (indexSignatures.length === 0) {
+        return { status: "error", message: `${path3}.${key} is not allowed` };
+      }
+      const indexValue = input[key];
+      let matched = false;
+      for (const indexSignature of indexSignatures) {
+        if (!matchesIndexKeyType({ keyType: indexSignature.keyType, key })) {
+          continue;
+        }
+        const indexResult = validateType(indexSignature.type, indexValue, `${path3}.${key}`);
+        if (indexResult.status === "success") {
+          matched = true;
+          break;
+        }
+      }
+      if (!matched) {
+        return { status: "error", message: `${path3}.${key} is not allowed` };
+      }
+    }
+    return { status: "success" };
+  }
+  if (/^[A-Za-z_][A-Za-z0-9_]*(?:<.+>)?$/.test(type)) {
+    if (/^[A-Za-z_][A-Za-z0-9_]*<.+>$/.test(type)) {
+      return { status: "error", message: `${path3}: unresolved utility ${type}` };
+    }
+    return { status: "error", message: `${path3}: unresolved type ${type}` };
+  }
+  return { status: "success" };
+};
+var validateInputByType = async ({
+  typeText,
+  value,
+  rootKey,
+  filePath
+}) => {
+  if (!typeText || typeText.trim() === "" || typeText.trim() === "any") {
+    return { status: "success" };
+  }
+  if (process.env.NODE_ENV === "production") {
+    return { status: "success" };
+  }
+  const devkitModuleId = "@luckystack/devkit";
+  const devkit = await import(devkitModuleId);
+  const resolvedType = devkit.resolveRuntimeTypeText({ typeText, filePath });
+  if (resolvedType.status === "error") {
+    return { status: "error", message: `${rootKey}: ${resolvedType.message}` };
+  }
+  return validateType(resolvedType.typeText, value, rootKey);
+};
+
+// src/checkOrigin.ts
+var normalizeOrigin = ({ value, secure }) => {
+  const trimmedValue = value.trim().toLowerCase();
+  if (!trimmedValue) {
+    return "";
+  }
+  const withProtocol = trimmedValue.startsWith("http://") || trimmedValue.startsWith("https://") ? trimmedValue : `http${secure ? "s" : ""}://${trimmedValue}`;
+  const extractedOrigin = /^(https?:\/\/[^/?#]+)/.exec(withProtocol)?.[1] || "";
+  if (!extractedOrigin) {
+    return "";
+  }
+  return extractedOrigin.replace(/^http:\/\/(.+):80$/i, "http://$1").replace(/^https:\/\/(.+):443$/i, "https://$1");
+};
+var isLocalhostOrigin = (normalized) => {
+  return /^https?:\/\/localhost(:\d+)?$/i.test(normalized);
+};
+var allowedOrigin = (origin) => {
+  const secure = process.env.SECURE === "true";
+  const cors = getProjectConfig().http.cors;
+  const configured = cors.allowedOrigins;
+  const { ip: bindIp, port: bindPort } = getBindAddress();
+  const location = bindPort ? `http${secure ? "s" : ""}://${bindIp}:${bindPort}` : `http${secure ? "s" : ""}://${bindIp}`;
+  const normalizedOrigin = normalizeOrigin({ value: origin, secure });
+  if (cors.allowLocalhost && normalizedOrigin && isLocalhostOrigin(normalizedOrigin)) {
+    return true;
+  }
+  if (typeof configured === "function") {
+    if (normalizedOrigin === location) return true;
+    if (configured(origin)) return true;
+  } else {
+    const normalizedAllowedOrigins = new Set(
+      [location, ...configured].map((value) => normalizeOrigin({ value, secure })).filter(Boolean)
+    );
+    if (normalizedOrigin && normalizedAllowedOrigins.has(normalizedOrigin)) {
+      return true;
+    }
+  }
+  const debugAllowedOrigins = typeof configured === "function" ? ["<dynamic-resolver>", location] : [location, ...configured].map((value) => normalizeOrigin({ value, secure })).filter(Boolean);
+  if (getProjectConfig().logging.devLogs) {
+    getLogger().warn("cors: origin not allowed", {
+      origin,
+      normalizedOrigin,
+      allowedOrigins: debugAllowedOrigins,
+      allowLocalhost: cors.allowLocalhost
+    });
+  }
+  void dispatchHook("corsRejected", {
+    origin,
+    normalizedOrigin,
+    allowedOrigins: debugAllowedOrigins,
+    allowLocalhost: cors.allowLocalhost
+  });
+  return false;
+};
+var checkOrigin_default = allowedOrigin;
+
+// 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/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((resolve) => setTimeout(resolve, WAIT_FOR_SOCKET_INTERVAL_MS));
+    i++;
+    if (i > WAIT_FOR_SOCKET_MAX_ITERATIONS) {
+      return null;
+    }
+  }
+  return socket;
+};
+
+// src/cancelRegistry.ts
+var syncControllers = /* @__PURE__ */ new Map();
+var apiControllers = /* @__PURE__ */ new Map();
+var buildKey = (socketId, identifier) => `${socketId}:${String(identifier)}`;
+var registerSyncAbortController = (socketId, cb, controller) => {
+  const key = buildKey(socketId, cb);
+  syncControllers.set(key, controller);
+  return key;
+};
+var unregisterSyncAbortController = (key) => {
+  syncControllers.delete(key);
+};
+var abortSyncByCb = (socketId, cb) => {
+  const key = buildKey(socketId, cb);
+  const controller = syncControllers.get(key);
+  if (!controller) return false;
+  controller.abort();
+  syncControllers.delete(key);
+  return true;
+};
+var registerApiAbortController = (socketId, responseIndex2, controller) => {
+  const key = buildKey(socketId, responseIndex2);
+  apiControllers.set(key, controller);
+  return key;
+};
+var unregisterApiAbortController = (key) => {
+  apiControllers.delete(key);
+};
+var abortApiByResponseIndex = (socketId, responseIndex2) => {
+  const key = buildKey(socketId, responseIndex2);
+  const controller = apiControllers.get(key);
+  if (!controller) return false;
+  controller.abort();
+  apiControllers.delete(key);
+  return true;
+};
+var abortAllForSocket = (socketId) => {
+  const prefix = `${socketId}:`;
+  for (const [key, controller] of syncControllers) {
+    if (key.startsWith(prefix)) {
+      controller.abort();
+      syncControllers.delete(key);
+    }
+  }
+  for (const [key, controller] of apiControllers) {
+    if (key.startsWith(prefix)) {
+      controller.abort();
+      apiControllers.delete(key);
+    }
+  }
+};
+
+// 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;
+};
+export {
+  BOOT_KEY_PREFIX,
+  DEFAULT_AVATAR_CONFIG,
+  DEFAULT_CLIENT_KEY,
+  DEFAULT_CSRF_CONFIG,
+  DEFAULT_ENV_FILES,
+  DEFAULT_PAGE_ROUTE_RULES,
+  DEFAULT_PROJECT_CONFIG,
+  GENERATED_API_DOCS_PATH,
+  GENERATED_API_SCHEMAS_PATH,
+  GENERATED_SOCKET_TYPES_PATH,
+  INVALID_ERROR_RESPONSE_CODE,
+  PUBLIC_DIR,
+  ROOT_DIR,
+  SERVER_DIR,
+  SERVER_FUNCTIONS_DIR,
+  SHARED_DIR,
+  SRC_DIR,
+  TSCONFIG_ALIAS_FILES,
+  UPLOADS_DIR,
+  abortAllForSocket,
+  abortApiByResponseIndex,
+  abortSyncByCb,
+  acquireLease,
+  checkOrigin_default as allowedOrigin,
+  applyErrorFormatter,
+  applySocketMiddlewares,
+  applyStrayKeyPrefix,
+  attachSocketRedisAdapter,
+  bootstrapEnv,
+  buildApiResponseEventName,
+  buildApiStreamEventName,
+  buildGetJoinedRoomsResponseEventName,
+  buildJoinRoomResponseEventName,
+  buildLeaveRoomResponseEventName,
+  buildSyncProgressEventName,
+  buildSyncResponseEventName,
+  captureException,
+  captureExceptionAcrossTrackers,
+  captureMessage,
+  captureMessageAcrossTrackers,
+  checkRateLimit,
+  clearAllHooks,
+  clearAllRateLimits,
+  clearCsrfToken,
+  clearRateLimit,
+  clearSocketMiddlewares,
+  collectSynchronizedEnvKeys,
+  computeSynchronizedEnvHashes,
+  createDevLogger,
+  createLocalizedNormalizer,
+  defaultHttpStatusForResponse,
+  defaultRateLimitStrategy,
+  defaultRedisKeyFormatter,
+  dispatchHook,
+  dispatchSyncHook,
+  enqueueApiRequest,
+  enqueueSyncRequest,
+  env,
+  extractLanguageFromHeader,
+  extractTokenFromRequest,
+  extractTokenFromSocket,
+  flushApiQueue,
+  flushSyncQueue,
+  formatKey,
+  getActiveErrorTrackers,
+  getApiQueueSize,
+  getAvatarConfig,
+  getBindAddress,
+  getCookieValue,
+  getCsrfConfig,
+  getCsrfToken,
+  getDeployConfig,
+  getEffectiveHttpMethod,
+  getEmailSender,
+  getEmailSenderByName,
+  getEnvFiles,
+  getErrorFormatter,
+  getGeneratedApiDocsPath,
+  getGeneratedApiSchemasPath,
+  getGeneratedSocketTypesPath,
+  getIoInstance,
+  getLocaleReloader,
+  getLocalizedNormalizer,
+  getLogger,
+  getNotifier,
+  getParams,
+  getPrismaClient,
+  getPrismaClientFor,
+  getPrismaClientKeys,
+  getProjectConfig,
+  getProjectName,
+  getPublicDir,
+  getRateLimitStatus,
+  getRateLimitStrategy,
+  getRedactedLogKeys,
+  getRedisClient,
+  getRedisClientFor,
+  getRedisClientKeys,
+  getRedisConnectionOptions,
+  getRedisKeyFormatter,
+  getRegisteredApiMethod,
+  getRuntimeApiMaps,
+  getRuntimeSyncMaps,
+  getServerDir,
+  getServerFunctionDirs,
+  getServerFunctionsDir,
+  getServicesConfig,
+  getSharedDir,
+  getSocketMiddlewares,
+  getSrcDir,
+  getSyncQueueSize,
+  getUploadsDir,
+  hasCookie,
+  hashSynchronizedValue,
+  httpFetch,
+  incrementResponseIndex,
+  inferHttpMethod,
+  initConsolelog,
+  initSharedSentry,
+  isApiMethodMapRegistered,
+  isDeployConfigRegistered,
+  isEmailSenderRegistered,
+  isErrorParamArray,
+  isFalsy,
+  isLocalizedNormalizerRegistered,
+  isLoggerRegistered,
+  isMethodAllowed,
+  isOnline,
+  isPrismaClientRegistered,
+  isProduction,
+  isProjectConfigRegistered,
+  isRedactedLogKey,
+  isRedisClientRegistered,
+  isRuntimeMapsProviderRegistered,
+  isServicesConfigRegistered,
+  listEmailSenderNames,
+  loadEnvFiles,
+  normalizeErrorResponse,
+  normalizeErrorResponseCore,
+  notify,
+  parseServiceRouteName,
+  parseTransportRouteName,
+  prisma,
+  processUpload,
+  readBootUuid,
+  recordMetricAcrossTrackers,
+  redis,
+  registerApiAbortController,
+  registerApiMethodMap,
+  registerAvatarConfig,
+  registerBindAddress,
+  registerCsrfConfig,
+  registerDeployConfig,
+  registerEmailSender,
+  registerEmailSenders,
+  registerErrorFormatter,
+  registerErrorTracker,
+  registerErrorTrackers,
+  registerHook,
+  registerLocaleReloader,
+  registerLocalizedNormalizer,
+  registerLogger,
+  registerNotifier,
+  registerPrismaClient,
+  registerProjectConfig,
+  registerRateLimitStrategy,
+  registerRedactedLogKeys,
+  registerRedisClient,
+  registerRedisKeyFormatter,
+  registerRuntimeMapsProvider,
+  registerServicesConfig,
+  registerSocketMiddleware,
+  registerSyncAbortController,
+  registerSyncHook,
+  releaseLease,
+  removeApiQueueItem,
+  removeApiQueueItemsByKey,
+  removeSyncQueueItem,
+  renewLease,
+  resetClientsForTests,
+  resetCsrfConfigForTests,
+  resetLoggerForTests,
+  resetRedactedLogKeysForTests,
+  resetRedisKeyFormatterForTests,
+  resolveEnvKey,
+  resolveErrorMessage,
+  resolveFromRoot,
+  serveAvatar,
+  setErrorTrackerUser,
+  setIoInstance,
+  setSentryUser,
+  setSocket,
+  sleep,
+  socket,
+  socketEventNames,
+  startSpan,
+  startSpanAcrossTrackers,
+  tryCatch,
+  unregisterApiAbortController,
+  unregisterSyncAbortController,
+  validateInputByType,
+  validatePagePath,
+  validateRequest,
+  waitForSocket,
+  writeBootUuid
+};
+//# sourceMappingURL=index.js.map