timeback 0.1.2 → 0.1.3

package/dist/server/adapters/svelte-kit.d.ts

@@ -66,7 +66,7 @@ export declare function svelteKitHandler<TEvent extends SvelteKitRequestEvent>(o
  * - `toSvelteKitHandler(timeback)`
  * - `toSvelteKitHandler(timeback.handle)`
  *
- * Also accepts identity-only instances from `createIdentityServer()`.
+ * Also accepts identity-only instances from `createTimebackIdentity()`.
  *
  * @param input - Timeback instance or handlers (full or identity-only)
  * @returns Object with HTTP method handlers for SvelteKit

package/dist/server/adapters/svelte-kit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"svelte-kit.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/svelte-kit.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,KAAK,EACX,gBAAgB,EAChB,uBAAuB,EACvB,iBAAiB,EACjB,qBAAqB,EAErB,MAAM,SAAS,CAAA;AA2BhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,wBAAsB,gBAAgB,CAAC,MAAM,SAAS,qBAAqB,EAC1E,OAAO,EAAE,uBAAuB,CAAC,MAAM,CAAC,GACtC,OAAO,CAAC,QAAQ,CAAC,CA8EnB;AAMD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,gBAAgB,GAAG,iBAAiB,CAgB7E"}
+{"version":3,"file":"svelte-kit.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/svelte-kit.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,KAAK,EACX,gBAAgB,EAChB,uBAAuB,EACvB,iBAAiB,EACjB,qBAAqB,EAErB,MAAM,SAAS,CAAA;AAMhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,wBAAsB,gBAAgB,CAAC,MAAM,SAAS,qBAAqB,EAC1E,OAAO,EAAE,uBAAuB,CAAC,MAAM,CAAC,GACtC,OAAO,CAAC,QAAQ,CAAC,CAqDnB;AAMD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,gBAAgB,GAAG,iBAAiB,CAgB7E"}

package/dist/server/adapters/svelte-kit.js

@@ -17,6 +17,33 @@ var __toESM = (mod, isNodeMode, target) => {
 };
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// src/server/lib/utils.ts
+function mapEnvForApi(env) {
+  if (env === "local" || env === "staging") {
+    return "staging";
+  }
+  return "production";
+}
+function jsonResponse(data, status = 200, headers) {
+  const responseHeaders = new Headers(headers);
+  responseHeaders.set("Content-Type", "application/json");
+  return new Response(JSON.stringify(data), { status, headers: responseHeaders });
+}
+function redirectResponse(url, headers) {
+  const responseHeaders = new Headers(headers);
+  responseHeaders.set("Location", url);
+  return new Response(null, { status: 302, headers: responseHeaders });
+}
+function encodeBase64Url(data) {
+  const json = JSON.stringify(data);
+  return btoa(json).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function decodeBase64Url(encoded) {
+  const padded = encoded.replace(/-/g, "+").replace(/_/g, "/");
+  const json = atob(padded);
+  return JSON.parse(json);
+}
+
 // src/shared/constants.ts
 var ROUTES = {
   ACTIVITY: "/activity",
@@ -30,443 +57,87 @@ var ROUTES = {
   }
 };
 
-// ../internal/logger/src/debug.ts
-var patterns = null;
-var debugAll = false;
-var debugEnvSet = false;
-function patternToRegex(pattern) {
-  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
-  const regexStr = escaped.replace(/\*/g, ".*");
-  return new RegExp(`^${regexStr}$`);
-}
-function parseDebugEnv() {
-  if (patterns !== null)
-    return;
-  patterns = [];
-  if (typeof process === "undefined" || !process.env?.DEBUG) {
-    debugEnvSet = false;
-    return;
-  }
-  debugEnvSet = true;
-  const debugValue = process.env.DEBUG.trim();
-  if (debugValue === "1" || debugValue === "true" || debugValue === "*") {
-    debugAll = true;
-    return;
-  }
-  const parts = debugValue.split(",").map((p) => p.trim()).filter(Boolean);
-  for (const part of parts) {
-    if (part.startsWith("-")) {
-      patterns.push({
-        regex: patternToRegex(part.slice(1)),
-        exclude: true
-      });
-    } else {
-      patterns.push({
-        regex: patternToRegex(part),
-        exclude: false
-      });
-    }
-  }
-  const hasInclude = patterns.some((p) => !p.exclude);
-  if (!hasInclude && patterns.length > 0) {
-    debugAll = true;
-  }
-}
-function shouldShowDebug(scope) {
-  parseDebugEnv();
-  if (!debugEnvSet) {
-    return true;
-  }
-  if (debugAll) {
-    if (scope) {
-      for (const pattern of patterns) {
-        if (pattern.exclude && pattern.regex.test(scope)) {
-          return false;
-        }
-      }
-    }
-    return true;
-  }
-  if (!scope) {
-    return false;
-  }
-  for (const pattern of patterns) {
-    if (pattern.exclude && pattern.regex.test(scope)) {
-      return false;
-    }
-  }
-  for (const pattern of patterns) {
-    if (!pattern.exclude && pattern.regex.test(scope)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-// ../internal/logger/src/env.ts
-function isBrowser() {
-  return typeof globalThis !== "undefined" && "window" in globalThis;
-}
-function detectEnvironment() {
-  if (isBrowser()) {
-    return "browser";
+// src/server/adapters/utils.ts
+function normalizePathname(path) {
+  const raw = path.trim();
+  if (raw === "") {
+    return "/";
   }
-  if (typeof process !== "undefined" && process.env) {
-    if (process.env["NODE_ENV"] === "test" || process.env["BUN_ENV"] === "test") {
-      return "test";
-    }
-    if (false) {}
-    if (process.env.CI || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI || process.env.CIRCLECI || process.env.JENKINS_URL || process.env.BUILDKITE) {
-      return "ci";
-    }
+  const queryIndex = raw.indexOf("?");
+  if (queryIndex === -1) {
+    return raw;
   }
-  return "terminal";
-}
-
-// ../internal/logger/src/formatters/terminal.ts
-var nodeInspect;
-if (!isBrowser()) {
-  try {
-    const util = await import("node:util");
-    nodeInspect = util.inspect;
-  } catch {}
-}
-var colors = {
-  reset: "\x1B[0m",
-  bold: "\x1B[1m",
-  dim: "\x1B[2m",
-  red: "\x1B[31m",
-  yellow: "\x1B[33m",
-  blue: "\x1B[34m",
-  cyan: "\x1B[36m"
-};
-function getLevelColor(level) {
-  switch (level) {
-    case "debug":
-      return colors.blue;
-    case "info":
-      return colors.cyan;
-    case "warn":
-      return colors.yellow;
-    case "error":
-      return colors.red;
+  const pathname = raw.slice(0, queryIndex);
+  if (pathname === "") {
+    return "/";
   }
+  return pathname;
 }
-function getConsoleMethod(level) {
-  switch (level) {
-    case "debug":
-      return console.debug;
-    case "info":
-      return console.info;
-    case "warn":
-      return console.warn;
-    case "error":
-      return console.error;
+function normalizeBasePath(basePath) {
+  let raw = normalizePathname(basePath);
+  if (raw !== "" && !raw.startsWith("/")) {
+    raw = `/${raw}`;
   }
-}
-function formatContext(context) {
-  if (nodeInspect) {
-    return nodeInspect(context, {
-      depth: null,
-      colors: true,
-      breakLength: 80,
-      compact: false
-    });
+  if (raw === "/" || raw === "") {
+    return "";
   }
-  return JSON.stringify(context, null, 2);
-}
-var terminalFormatter = (entry) => {
-  const levelColor = getLevelColor(entry.level);
-  const consoleMethod = getConsoleMethod(entry.level);
-  const levelUpper = entry.level.toUpperCase().padEnd(5);
-  const isoString = entry.timestamp.toISOString().replace(/\.\d{3}Z$/, "");
-  const timestamp = `${colors.dim}[${isoString}]${colors.reset}`;
-  const level = `${levelColor}${levelUpper}${colors.reset}`;
-  const scope = entry.scope ? `${colors.bold}[${entry.scope}]${colors.reset} ` : "";
-  const prefix = `${timestamp} ${level} ${scope}${entry.message}`;
-  if (entry.context && Object.keys(entry.context).length > 0) {
-    consoleMethod(prefix, formatContext(entry.context));
-  } else {
-    consoleMethod(prefix);
+  if (raw.endsWith("/")) {
+    return raw.slice(0, -1);
   }
-};
-// ../internal/logger/src/formatters/ci.ts
-var LEVEL_PREFIX = {
-  debug: "[DEBUG]",
-  info: "[INFO]",
-  warn: "[WARN]",
-  error: "[ERROR]"
-};
-function formatContext2(context) {
-  return Object.entries(context).map(([key, value]) => `${key}=${formatValue(value)}`).join(" ");
-}
-function formatValue(value) {
-  if (typeof value === "string")
-    return value;
-  if (typeof value === "number")
-    return String(value);
-  if (typeof value === "boolean")
-    return String(value);
-  if (value === null)
-    return "null";
-  if (value === undefined)
-    return "undefined";
-  return JSON.stringify(value);
+  return raw;
 }
-var ciFormatter = (entry) => {
-  const parts = [];
-  parts.push(entry.timestamp.toISOString());
-  parts.push(LEVEL_PREFIX[entry.level]);
-  if (entry.scope) {
-    parts.push(`[${entry.scope}]`);
+function matchTimebackRoute(params) {
+  const method = params.method.toUpperCase();
+  const pathname = normalizePathname(params.pathname);
+  const callbackPath = params.callbackPath ? normalizePathname(params.callbackPath) : undefined;
+  if (callbackPath && pathname === callbackPath) {
+    return method === "GET" ? "identity.callback" : null;
   }
-  parts.push(entry.message);
-  if (entry.context && Object.keys(entry.context).length > 0) {
-    parts.push(formatContext2(entry.context));
-  }
-  console.log(parts.join(" "));
-};
-// ../internal/logger/src/formatters/production.ts
-var productionFormatter = (entry) => {
-  const output = {
-    timestamp: entry.timestamp.toISOString(),
-    level: entry.level,
-    ...entry.scope && { scope: entry.scope },
-    msg: entry.message
+  const basePathInput = params.basePath;
+  const hasBasePath = basePathInput !== undefined;
+  const basePath = hasBasePath ? normalizeBasePath(basePathInput) : undefined;
+  const matchesRelative = (relative) => {
+    if (method === "GET") {
+      if (relative === ROUTES.IDENTITY.SIGNIN)
+        return "identity.signIn";
+      if (relative === ROUTES.IDENTITY.CALLBACK)
+        return "identity.callback";
+      if (relative === ROUTES.IDENTITY.SIGNOUT)
+        return "identity.signOut";
+      if (relative === ROUTES.USER.ME)
+        return "user.me";
+    }
+    if (method === "POST") {
+      if (relative === ROUTES.ACTIVITY)
+        return "activity";
+    }
+    return null;
   };
-  if (entry.context && Object.keys(entry.context).length > 0) {
-    Object.assign(output, entry.context);
-  }
-  console.log(JSON.stringify(output));
-};
-// ../internal/logger/src/formatters/browser.ts
-var LEVEL_STYLES = {
-  debug: "color: gray",
-  info: "color: #0ea5e9",
-  warn: "color: #f59e0b",
-  error: "color: #ef4444; font-weight: bold"
-};
-var LEVEL_METHODS = {
-  debug: "log",
-  info: "info",
-  warn: "warn",
-  error: "error"
-};
-var browserFormatter = (entry) => {
-  const method = LEVEL_METHODS[entry.level];
-  const style = LEVEL_STYLES[entry.level];
-  const prefix = entry.scope ? `[${entry.scope}]` : "";
-  const label = `%c${prefix} ${entry.message}`;
-  if (entry.context && Object.keys(entry.context).length > 0) {
-    console[method](label, style, entry.context);
-  } else {
-    console[method](label, style);
-  }
-};
-// ../internal/logger/src/logger.ts
-var LOG_LEVELS = ["debug", "info", "warn", "error"];
-function getFormatter(env) {
-  switch (env) {
-    case "terminal":
-      return terminalFormatter;
-    case "ci":
-      return ciFormatter;
-    case "production":
-      return productionFormatter;
-    case "browser":
-      return browserFormatter;
-    case "test":
-      return () => {};
-  }
-}
-function getDefaultMinLevel() {
-  if (typeof process !== "undefined" && process.env?.DEBUG) {
-    return "debug";
-  }
-  return "info";
-}
-function shouldLog(level, minLevel) {
-  return LOG_LEVELS.indexOf(level) >= LOG_LEVELS.indexOf(minLevel);
-}
-
-class Logger {
-  scope;
-  minLevel;
-  environment;
-  formatter;
-  defaultContext;
-  constructor(options = {}) {
-    this.scope = options.scope;
-    this.minLevel = options.minLevel ?? getDefaultMinLevel();
-    this.defaultContext = options.defaultContext ?? {};
-    this.environment = options.environment ?? detectEnvironment();
-    this.formatter = getFormatter(this.environment);
-  }
-  child(scope) {
-    const childScope = this.scope ? `${this.scope}:${scope}` : scope;
-    return new Logger({
-      scope: childScope,
-      minLevel: this.minLevel,
-      environment: this.environment,
-      defaultContext: { ...this.defaultContext }
-    });
-  }
-  withContext(context) {
-    return new Logger({
-      scope: this.scope,
-      minLevel: this.minLevel,
-      environment: this.environment,
-      defaultContext: { ...this.defaultContext, ...context }
-    });
-  }
-  debug(message, context) {
-    this.log("debug", message, context);
-  }
-  info(message, context) {
-    this.log("info", message, context);
+  if (hasBasePath && basePath !== undefined) {
+    if (basePath !== "" && pathname === basePath)
+      return null;
+    if (basePath !== "" && !pathname.startsWith(`${basePath}/`))
+      return null;
+    const relativeRaw = basePath === "" ? pathname : pathname.slice(basePath.length);
+    const relative = relativeRaw.startsWith("/") ? relativeRaw : `/${relativeRaw}`;
+    return matchesRelative(relative);
   }
-  warn(message, context) {
-    this.log("warn", message, context);
-  }
-  error(message, context) {
-    this.log("error", message, context);
-  }
-  log(level, message, context) {
-    if (level === "debug" && !shouldShowDebug(this.scope)) {
-      return;
-    }
-    if (!shouldLog(level, this.minLevel)) {
-      return;
-    }
-    const entry = {
-      level,
-      message,
-      scope: this.scope,
-      context: context || Object.keys(this.defaultContext).length > 0 ? { ...this.defaultContext, ...context } : undefined,
-      timestamp: new Date
-    };
-    this.formatter(entry);
-  }
-}
-function createLogger(options = {}) {
-  return new Logger(options);
-}
-// src/server/lib/logger.ts
-function isDebug() {
-  try {
-    const debug = typeof process === "undefined" ? undefined : process.env.DEBUG;
-    return debug === "1" || debug === "true";
-  } catch {
-    return false;
-  }
-}
-function createScopedLogger(scope) {
-  return createLogger({
-    scope: `timeback:${scope}`,
-    minLevel: isDebug() ? "debug" : "warn"
-  });
-}
-var ssoLog = createScopedLogger("sso");
-var oidcLog = createScopedLogger("oidc");
-
-// src/server/lib/oidc.ts
-var discoveryCache = new Map;
-async function fetchDiscoveryDocument(issuer) {
-  const cached = discoveryCache.get(issuer);
-  if (cached) {
-    return cached;
-  }
-  const url = `${issuer}/.well-known/openid-configuration`;
-  const response = await fetch(url);
-  if (!response.ok) {
-    oidcLog.error("Discovery fetch failed", { status: response.status });
-    throw new Error(`Failed to fetch OIDC discovery: ${response.statusText}`);
-  }
-  const doc = await response.json();
-  oidcLog.debug("Fetched OIDC discovery document", {
-    authEndpoint: doc.authorization_endpoint,
-    tokenEndpoint: doc.token_endpoint
-  });
-  discoveryCache.set(issuer, doc);
-  return doc;
-}
-function getIssuer(env) {
-  switch (env) {
-    case "production":
-      return "https://cognito-idp.us-east-1.amazonaws.com/us-east-1_3uhuoRM3R";
-    case "staging":
-      return "https://cognito-idp.us-east-1.amazonaws.com/us-east-1_5EUwTP9XD";
-    case "local":
-      throw new Error("Local environment is not yet supported for OIDC");
+  if (method === "GET") {
+    if (pathname.endsWith(ROUTES.IDENTITY.SIGNIN))
+      return "identity.signIn";
+    if (pathname.endsWith(ROUTES.IDENTITY.CALLBACK))
+      return "identity.callback";
+    if (pathname.endsWith(ROUTES.IDENTITY.SIGNOUT))
+      return "identity.signOut";
+    if (pathname.endsWith(ROUTES.USER.ME))
+      return "user.me";
   }
-}
-async function buildAuthorizationUrl(params) {
-  const discovery = await fetchDiscoveryDocument(params.issuer);
-  const url = new URL(discovery.authorization_endpoint);
-  url.searchParams.set("response_type", "code");
-  url.searchParams.set("client_id", params.clientId);
-  url.searchParams.set("redirect_uri", params.redirectUri);
-  url.searchParams.set("scope", "openid profile email");
-  url.searchParams.set("state", params.state);
-  return url.toString();
-}
-async function exchangeCodeForTokens(params) {
-  const discovery = await fetchDiscoveryDocument(params.issuer);
-  const response = await fetch(discovery.token_endpoint, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/x-www-form-urlencoded"
-    },
-    body: new URLSearchParams({
-      grant_type: "authorization_code",
-      client_id: params.clientId,
-      client_secret: params.clientSecret,
-      code: params.code,
-      redirect_uri: params.redirectUri
-    })
-  });
-  if (!response.ok) {
-    const text = await response.text();
-    oidcLog.error("Token exchange failed", { status: response.status, body: text });
-    throw new Error(`Token exchange failed: ${response.status} ${text}`);
+  if (method === "POST") {
+    if (pathname.endsWith(ROUTES.ACTIVITY))
+      return "activity";
   }
-  const tokens = await response.json();
-  oidcLog.debug("Received tokens from IdP", { expiresIn: tokens.expires_in });
-  return tokens;
-}
-async function getUserInfo(params) {
-  const discovery = await fetchDiscoveryDocument(params.issuer);
-  const response = await fetch(discovery.userinfo_endpoint, {
-    headers: {
-      Authorization: `Bearer ${params.accessToken}`
-    }
-  });
-  if (!response.ok) {
-    throw new Error(`UserInfo request failed: ${response.statusText}`);
-  }
-  return response.json();
-}
-// src/server/lib/utils.ts
-function jsonResponse(data, status = 200, headers) {
-  const responseHeaders = new Headers(headers);
-  responseHeaders.set("Content-Type", "application/json");
-  return new Response(JSON.stringify(data), { status, headers: responseHeaders });
+  return null;
 }
-function redirectResponse(url, headers) {
-  const responseHeaders = new Headers(headers);
-  responseHeaders.set("Location", url);
-  return new Response(null, { status: 302, headers: responseHeaders });
-}
-function encodeBase64Url(data) {
-  const json = JSON.stringify(data);
-  return btoa(json).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-}
-function decodeBase64Url(encoded) {
-  const padded = encoded.replace(/-/g, "+").replace(/_/g, "/");
-  const json = atob(padded);
-  return JSON.parse(json);
-}
-// src/server/adapters/utils.ts
 function getHandlers(input) {
   return "handle" in input ? input.handle : input;
 }
@@ -488,36 +159,34 @@ function toNativeHandler(input) {
     const url = new URL(req.url);
     const path = url.pathname;
     const method = req.method;
-    if (method === "GET") {
-      if (path.endsWith(ROUTES.IDENTITY.SIGNIN)) {
-        return handle.identity.signIn(req);
-      }
-      if (path.endsWith(ROUTES.IDENTITY.CALLBACK) || callbackPath && path.endsWith(callbackPath)) {
-        return handle.identity.callback(req);
-      }
-      if (path.endsWith(ROUTES.IDENTITY.SIGNOUT)) {
-        return Promise.resolve(handle.identity.signOut());
-      }
-    }
-    if (hasUserHandler(handle)) {
-      if (method === "GET" && path.endsWith(ROUTES.USER.ME)) {
-        return handle.user.me(req);
+    const route = matchTimebackRoute({
+      pathname: path,
+      method,
+      callbackPath
+    });
+    if (route === "identity.signIn")
+      return handle.identity.signIn(req);
+    if (route === "identity.callback")
+      return handle.identity.callback(req);
+    if (route === "identity.signOut")
+      return Promise.resolve(handle.identity.signOut());
+    if (route === "user.me") {
+      if (!hasUserHandler(handle)) {
+        return Promise.resolve(jsonResponse({ error: "Not found" }, 404));
       }
+      return handle.user.me(req);
     }
-    if (hasActivityHandler(handle)) {
-      if (method === "POST" && path.endsWith(ROUTES.ACTIVITY)) {
-        return handle.activity(req);
+    if (route === "activity") {
+      if (!hasActivityHandler(handle)) {
+        return Promise.resolve(jsonResponse({ error: "Not found" }, 404));
       }
+      return handle.activity(req);
     }
     return Promise.resolve(jsonResponse({ error: "Not found" }, 404));
   };
 }
 
 // src/server/adapters/svelte-kit.ts
-function isTimebackPath(pathname, basePath) {
-  const normalizedBase = basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
-  return pathname.startsWith(`${normalizedBase}/`) || pathname === normalizedBase || pathname.endsWith(ROUTES.IDENTITY.SIGNIN) || pathname.endsWith(ROUTES.IDENTITY.CALLBACK) || pathname.endsWith(ROUTES.IDENTITY.SIGNOUT) || pathname.endsWith(ROUTES.ACTIVITY) || pathname.endsWith(ROUTES.USER.ME);
-}
 async function svelteKitHandler(options) {
   const {
     timeback,
@@ -534,32 +203,24 @@ async function svelteKitHandler(options) {
   const handle = getHandlers(timeback);
   const path = url.pathname;
   const method = request.method;
-  if (callbackPath && path === callbackPath && method === "GET") {
-    return await handle.identity.callback(request);
-  }
-  if (!isTimebackPath(path, basePath)) {
+  const route = matchTimebackRoute({ pathname: path, method, basePath, callbackPath });
+  if (!route)
     return resolve(event);
-  }
-  if (method === "GET") {
-    if (path.endsWith(ROUTES.IDENTITY.SIGNIN)) {
-      return await handle.identity.signIn(request);
-    }
-    if (path.endsWith(ROUTES.IDENTITY.CALLBACK)) {
-      return await handle.identity.callback(request);
-    }
-    if (path.endsWith(ROUTES.IDENTITY.SIGNOUT)) {
-      return handle.identity.signOut();
-    }
-  }
-  if (hasUserHandler(handle)) {
-    if (method === "GET" && path.endsWith(ROUTES.USER.ME)) {
-      return await handle.user.me(request);
-    }
-  }
-  if (hasActivityHandler(handle)) {
-    if (method === "POST" && path.endsWith(ROUTES.ACTIVITY)) {
-      return await handle.activity(request);
-    }
+  if (route === "identity.signOut")
+    return handle.identity.signOut();
+  if (route === "identity.signIn")
+    return await handle.identity.signIn(request);
+  if (route === "identity.callback")
+    return await handle.identity.callback(request);
+  if (route === "user.me") {
+    if (!hasUserHandler(handle))
+      return resolve(event);
+    return await handle.user.me(request);
+  }
+  if (route === "activity") {
+    if (!hasActivityHandler(handle))
+      return resolve(event);
+    return await handle.activity(request);
   }
   return resolve(event);
 }

package/dist/server/adapters/tanstack-start.d.ts

@@ -15,7 +15,7 @@ import type { AnyTimebackInput, TanStackStartHandlerOptions, TanStackStartHandle
  * - `toTanStackStartHandler(timeback)`
  * - `toTanStackStartHandler(timeback.handle)`
  *
- * Also accepts identity-only instances from `createIdentityServer()`.
+ * Also accepts identity-only instances from `createTimebackIdentity()`.
  *
  * @param input - Timeback instance or handlers (full or identity-only), or options object
  * @returns Object with HTTP method handlers for TanStack Start

package/dist/server/adapters/tanstack-start.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tanstack-start.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/tanstack-start.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,KAAK,EACX,gBAAgB,EAEhB,2BAA2B,EAC3B,qBAAqB,EACrB,MAAM,SAAS,CAAA;AAMhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,sBAAsB,CACrC,KAAK,EAAE,gBAAgB,GAAG,2BAA2B,GACnD,qBAAqB,CAkDvB;AAcD;;GAEG;AACH,eAAO,MAAM,oBAAoB,+BAAyB,CAAA"}
+{"version":3,"file":"tanstack-start.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/tanstack-start.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,KAAK,EACX,gBAAgB,EAEhB,2BAA2B,EAC3B,qBAAqB,EACrB,MAAM,SAAS,CAAA;AAMhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,sBAAsB,CACrC,KAAK,EAAE,gBAAgB,GAAG,2BAA2B,GACnD,qBAAqB,CAsCvB;AAcD;;GAEG;AACH,eAAO,MAAM,oBAAoB,+BAAyB,CAAA"}