@ultrst-armada/kloks 1.7.0 → 1.8.0

package/.krusbl-release-attestation.json

@@ -1,8 +1,8 @@
 {
   "schema": 1,
   "packageName": "@ultrst-armada/kloks",
-  "version": "1.7.0",
-  "sourceCommit": "b794ff2065167edac2d5c817897b5244e9136952",
+  "version": "1.8.0",
+  "sourceCommit": "d364f4fd5a705bea93c4fb0a93ff9740c1050f49",
   "releaseWorkflow": "npm Release",
-  "workflowRunId": "40036485979"
+  "workflowRunId": "40208606705"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ultrst-armada/kloks",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "private": false,
   "publishConfig": {
     "access": "public",

package/packages/backend/dist/{BaseStorageAdapter-tosOoSUg.d.ts → BaseStorageAdapter-EUCSvJse.d.ts}

@@ -1,7 +1,7 @@
 import { SkipoBase } from '@ultrst-armada/kloks/functions';
 
 type StorageMode = 'local' | 'local_hosted' | 'remote';
-type StorageProviderType = 'local_fs' | 's3' | 'backblaze_b2' | 'b2' | 'cloudflare_r2' | 'r2' | 'supabase' | 'firebase' | 'google_drive';
+type StorageProviderType = 'local_fs' | 'backblaze_b2' | 'b2' | 'supabase' | 'firebase' | 'google_drive';
 interface StorageConfig {
     provider: StorageProviderType;
     mode?: StorageMode;
@@ -19,6 +19,12 @@ interface StorageConfig {
     keyId?: string;
     applicationKey?: string;
     accountId?: string;
+    googleClientId?: string;
+    googleRedirectUri?: string;
+    googleAccessToken?: string;
+    googleAccessTokenExpiresAt?: number;
+    googleRefreshToken?: string;
+    googleRootFolderId?: string;
 }
 interface FileInfo {
     path: string;

package/packages/backend/dist/auth/index.d.ts

@@ -26,31 +26,69 @@ declare class AdminGuard extends SkipoBase {
     static verifyUser(authHeaderOrToken: string | null | undefined, provider: BaseAccountProvider): Promise<AuthSession>;
 }
 
-/**
- * @file UnifiedAuthCore.ts
- * @description Strict Universal Authentication against "ultrst-users" and "ultrst-credentials".
- * Zero offline dummy fallbacks. Runs across Node.js, Vercel, and Cloudflare Workers (< 200 lines).
- */
-interface SystemUser {
+interface CanonicalAuthUser {
     id: string;
     email: string;
-    username: string;
     name: string;
+    username?: string;
+    role?: string;
+    status?: string;
+    appProfiles?: Record<string, unknown>;
+    emailVerified?: boolean;
+}
+interface CanonicalAuthSession {
+    session: Record<string, unknown>;
+    user: CanonicalAuthUser;
+}
+interface CanonicalAuthClientOptions {
+    baseUrl: string;
+    fetcher?: typeof fetch;
+    credentials?: RequestCredentials;
+}
+interface AuthResult {
+    success: boolean;
+    status: number;
+    user?: CanonicalAuthUser;
+    session?: Record<string, unknown>;
+    error?: string;
+    redirectUrl?: string;
+}
+declare class CanonicalAuthClient {
+    private readonly baseUrl;
+    private readonly fetcher;
+    private readonly credentials;
+    constructor(options: CanonicalAuthClientOptions);
+    private request;
+    signInEmail(email: string, password: string): Promise<AuthResult>;
+    signUpEmail(email: string, password: string, name: string): Promise<AuthResult>;
+    signInGoogle(callbackURL: string): Promise<AuthResult>;
+    requestGoogleDriveAccess(callbackURL?: string): Promise<AuthResult>;
+    getSession(cookie?: string): Promise<CanonicalAuthSession | null>;
+    signOut(): Promise<boolean>;
+}
+declare function createCanonicalAuthClient(baseUrl: string, fetcher?: typeof fetch): CanonicalAuthClient;
+
+interface SystemUser extends CanonicalAuthUser {
+    username: string;
     role: string;
     status: string;
-    appProfiles?: Record<string, any>;
+    appProfiles?: Record<string, unknown>;
+}
+interface AuthEnvironment {
+    SRKL_AUTH_BASE_URL?: string;
+    [key: string]: unknown;
 }
-declare function loginSystemUser(email: string, rawPass: string, isAdmin: boolean, queryDb: (sql: string, params?: unknown[]) => Promise<{
+declare function loginSystemUser(email: string, rawPass: string, isAdmin: boolean, _queryDb: (sql: string, params?: unknown[]) => Promise<{
     rows: any[];
-}>): Promise<{
+}>, env?: AuthEnvironment): Promise<{
     success: boolean;
     status: number;
     token?: string;
     user?: SystemUser;
     error?: string;
 }>;
-declare function resolveUserFromToken(tokenOrUserId: string, queryDb: (sql: string, params?: unknown[]) => Promise<{
+declare function resolveUserFromToken(tokenOrUserId: string, _queryDb: (sql: string, params?: unknown[]) => Promise<{
     rows: any[];
-}>): Promise<SystemUser | null>;
+}>, env?: AuthEnvironment): Promise<SystemUser | null>;
 
-export { AdminGuard, AuthSession, BaseAccountProvider, CreateUserData, LocalAccountProvider, PasswordHasher, type SystemUser, User, loginSystemUser, resolveUserFromToken };
+export { AdminGuard, type AuthEnvironment, type AuthResult, AuthSession, BaseAccountProvider, CanonicalAuthClient, type CanonicalAuthClientOptions, type CanonicalAuthSession, type CanonicalAuthUser, CreateUserData, LocalAccountProvider, PasswordHasher, type SystemUser, User, createCanonicalAuthClient, loginSystemUser, resolveUserFromToken };

package/packages/backend/dist/auth/index.js

@@ -3,20 +3,24 @@ import {
   BaseAccountProvider,
   LocalAccountProvider,
   PasswordHasher
-} from "../chunk-MPYASJ5A.js";
+} from "../chunk-HT2SEDHD.js";
 import {
+  CanonicalAuthClient,
   RateLimiter,
   SessionManager,
+  createCanonicalAuthClient,
   loginSystemUser,
   resolveUserFromToken
-} from "../chunk-ZDH4XI7W.js";
+} from "../chunk-M4GSR46Y.js";
 export {
   AdminGuard,
   BaseAccountProvider,
+  CanonicalAuthClient,
   LocalAccountProvider,
   PasswordHasher,
   RateLimiter,
   SessionManager,
+  createCanonicalAuthClient,
   loginSystemUser,
   resolveUserFromToken
 };

package/packages/backend/dist/{chunk-BI5RDDB4.js → chunk-3IUA66RS.js}

@@ -121,9 +121,10 @@ var SrklClient = class {
     const creds = account.credentials || {};
     const sId = (account.serviceId || "").toLowerCase();
     const isB2 = sId.includes("backblaze") || sId === "b2";
+    const isGoogle = sId.includes("google_drive") || sId.includes("googledrive") || sId === "google";
     return {
       id: `conn-srkl-${account.id}`,
-      provider: isB2 ? "backblaze_b2" : "aws_s3",
+      provider: isB2 ? "backblaze_b2" : isGoogle ? "google_drive" : "aws_s3",
       label: `SRKL: ${account.name || (isB2 ? "Backblaze" : "S3")}`,
       role: "redundant_clone",
       enabled: true,
@@ -137,7 +138,13 @@ var SrklClient = class {
       s3SecretAccessKey: creds.secretAccessKey || creds.applicationKey || creds.s3SecretAccessKey,
       s3BucketName: creds.bucketName || creds.s3BucketName,
       s3Region: creds.region || creds.s3Region,
-      s3Endpoint: creds.endpoint || creds.s3Endpoint
+      s3Endpoint: creds.endpoint || creds.s3Endpoint,
+      googleEmail: creds.email || account.credentials?.email || account.name,
+      googleRootFolderId: creds.rootFolderId,
+      googleRootFolderName: creds.rootFolderName,
+      googleAccessToken: creds.accessToken,
+      googleAccessTokenExpiresAt: creds.accessTokenExpiresAt,
+      googleRefreshToken: creds.refreshToken
     };
   }
 };

package/packages/backend/dist/{chunk-KSZ67VZJ.js → chunk-5RXXC6GE.js}

@@ -1,9 +1,9 @@
-import {
-  StorageAdapterFactory
-} from "./chunk-J2J24JVC.js";
 import {
   findUserWorkspace
 } from "./chunk-6K75XXFD.js";
+import {
+  StorageAdapterFactory
+} from "./chunk-SHZAQTIT.js";
 
 // src/services/workspaceGraphService.ts
 function slugify(name) {

package/packages/backend/dist/{chunk-Y3X3H2XX.js → chunk-BPFZCDS4.js}

@@ -1,16 +1,10 @@
-import {
-  workspaceGraphService
-} from "./chunk-KSZ67VZJ.js";
 import {
   getSrklAccounts,
   srklListBackblazeBuckets
-} from "./chunk-N4Z57FVR.js";
-import {
-  StorageAdapterFactory
-} from "./chunk-J2J24JVC.js";
+} from "./chunk-XHADDA75.js";
 import {
-  b2ListBuckets
-} from "./chunk-4QEMALXF.js";
+  workspaceGraphService
+} from "./chunk-5RXXC6GE.js";
 import {
   formatCanonicalWorkspaceFolderName,
   sanitizeWorkspaceName
@@ -25,12 +19,18 @@ import {
 import {
   queryUnifiedDb
 } from "./chunk-VAFCR2MS.js";
+import {
+  b2ListBuckets
+} from "./chunk-4QEMALXF.js";
+import {
+  StorageAdapterFactory
+} from "./chunk-SHZAQTIT.js";
 import {
   RateLimiter,
   SessionManager,
   loginSystemUser,
   resolveUserFromToken
-} from "./chunk-ZDH4XI7W.js";
+} from "./chunk-M4GSR46Y.js";
 import {
   createService,
   createServiceDefinition
@@ -56,12 +56,12 @@ var AuthServiceDefinition = createServiceDefinition({
     login: {
       id: "AuthService.login",
       name: "login",
-      handler: async (input) => loginSystemUser(input.email, input.password, Boolean(input.isAdmin), (sql, params) => queryUnifiedDb(sql, params, input.env))
+      handler: async (input) => loginSystemUser(input.email, input.password, Boolean(input.isAdmin), (sql, params) => queryUnifiedDb(sql, params, input.env), input.env)
     },
     resolveUser: {
       id: "AuthService.resolveUser",
       name: "resolveUser",
-      handler: async (input) => resolveUserFromToken(input.tokenOrUserId, (sql, params) => queryUnifiedDb(sql, params, input.env))
+      handler: async (input) => resolveUserFromToken(input.tokenOrUserId, (sql, params) => queryUnifiedDb(sql, params, input.env), input.env)
     },
     checkRateLimit: {
       id: "AuthService.checkRateLimit",

package/packages/backend/dist/{chunk-6QTNNZSE.js → chunk-BTMIK44G.js}

@@ -1,13 +1,9 @@
 import {
   createWorkspace,
   deleteWorkspace,
-  deleteWorkspaceFile,
   findUserWorkspace,
   getWorkspaces,
-  listWorkspaceFiles,
-  readWorkspaceFile,
-  updateWorkspace,
-  writeWorkspaceFile
+  updateWorkspace
 } from "./chunk-6K75XXFD.js";
 import {
   b2DownloadFile,
@@ -15,6 +11,9 @@ import {
   b2UploadFile,
   queryUnifiedDb
 } from "./chunk-VAFCR2MS.js";
+import {
+  GoogleDriveAdapter
+} from "./chunk-KKRWZDMN.js";
 
 // src/workspace/WorkspaceFS.ts
 import { SkipoBase } from "@ultrst-armada/kloks/functions";
@@ -135,58 +134,6 @@ var WorkspaceCloneSyncEngine = class extends SkipoBase3 {
   }
 };
 
-// src/workspace/RemoteWorkspaceService.ts
-var RemoteWorkspaceService = class {
-  type = "remote";
-  async findWorkspace(workspaceId, env) {
-    return await findUserWorkspace(workspaceId, env);
-  }
-  async listWorkspaces(userId, env) {
-    return await getWorkspaces(userId, env);
-  }
-  async createWorkspace(userId, data, env) {
-    return await createWorkspace(userId, data, env);
-  }
-  async updateWorkspace(userId, params, env) {
-    return await updateWorkspace(userId, params, env);
-  }
-  async deleteWorkspace(userId, workspaceId, env) {
-    return await deleteWorkspace(userId, workspaceId, env);
-  }
-  async readFile(workspaceId, filePath, env) {
-    const { workspace, connection } = await this.findWorkspace(workspaceId, env);
-    if (!workspace) throw new Error(`Workspace "${workspaceId}" not found.`);
-    const data = await readWorkspaceFile(workspace, connection, filePath);
-    if (!data) throw new Error(`File "${filePath}" not found in workspace "${workspaceId}".`);
-    return data;
-  }
-  async writeFile(workspaceId, filePath, content, env) {
-    const { workspace, connection } = await this.findWorkspace(workspaceId, env);
-    if (!workspace) throw new Error(`Workspace "${workspaceId}" not found.`);
-    await writeWorkspaceFile(workspace, connection, filePath, content);
-    const size = typeof content === "string" ? new TextEncoder().encode(content).length : content.byteLength;
-    return { success: true, path: filePath, sizeBytes: size };
-  }
-  async deleteFile(workspaceId, filePath, env) {
-    const { workspace, connection } = await this.findWorkspace(workspaceId, env);
-    if (!workspace) throw new Error(`Workspace "${workspaceId}" not found.`);
-    const deleted = await deleteWorkspaceFile(workspace, connection, filePath);
-    return { success: deleted };
-  }
-  async listFiles(workspaceId, subfolder = "", env) {
-    const { workspace, connection } = await this.findWorkspace(workspaceId, env);
-    if (!workspace) throw new Error(`Workspace "${workspaceId}" not found.`);
-    const files = await listWorkspaceFiles(workspace, connection, subfolder);
-    return files.map((f) => ({
-      path: f.fileName,
-      name: f.fileName.split("/").pop() || f.fileName,
-      sizeBytes: f.sizeBytes,
-      updatedAt: f.uploadTimestamp
-    }));
-  }
-};
-var remoteWorkspaceService = new RemoteWorkspaceService();
-
 // src/workspace/WorkingWorkspaceService.ts
 import fs2 from "fs";
 import path2 from "path";
@@ -245,8 +192,10 @@ function setWorkingWorkspaceConfig(cfg) {
   }
   return updated;
 }
-function getWorkingWorkspaceDir() {
-  const dir = getWorkingWorkspaceConfig().workingDirectory;
+function getWorkingWorkspaceDir(workspaceId = "default") {
+  const root = getWorkingWorkspaceConfig().workingDirectory;
+  const safeId = workspaceId.replace(/[^a-zA-Z0-9._-]/g, "_");
+  const dir = path.join(root, safeId);
   if (!fs.existsSync(dir)) {
     fs.mkdirSync(dir, { recursive: true });
   }
@@ -331,7 +280,7 @@ async function syncWorkspace(workspaceId) {
   }
   const { workspace, user, connection } = match;
   const folderKey = getWorkspaceFolderKey(workspace, user);
-  const workingDir = getWorkingWorkspaceDir();
+  const workingDir = getWorkingWorkspaceDir(workspaceId);
   const isB2 = workspace.storageProvider === "backblaze_b2" || workspace.storageConfig?.type === "b2";
   const syncedFiles = [];
   let uploadedCount = 0;
@@ -428,6 +377,86 @@ async function syncWorkspace(workspaceId) {
       };
     }
   }
+  const isGoogleDrive = workspace.storageProvider === "google_drive" || workspace.storageConfig?.type === "google_drive";
+  if (isGoogleDrive) {
+    const creds = workspace.storageConfig || connection?.credentials || connection || {};
+    const rootFolderId = creds.googleRootFolderId || creds.rootFolderId || workspace.googleRootFolderId;
+    const adapter = new GoogleDriveAdapter({
+      provider: "google_drive",
+      googleAccessToken: creds.googleAccessToken || creds.accessToken,
+      googleAccessTokenExpiresAt: creds.googleAccessTokenExpiresAt,
+      googleRefreshToken: creds.googleRefreshToken || creds.refreshToken,
+      googleClientId: creds.googleClientId || process.env.GOOGLE_CLIENT_ID,
+      googleRootFolderId: rootFolderId
+    });
+    try {
+      const remoteFiles = await adapter.list("");
+      const remoteMap = /* @__PURE__ */ new Map();
+      for (const rf of remoteFiles) {
+        if (rf.path) remoteMap.set(rf.path, { size: rf.size, timestamp: rf.modifiedAt });
+      }
+      const localFiles = await collectLocalFiles(workingDir);
+      const localMap = /* @__PURE__ */ new Map();
+      for (const lf of localFiles) {
+        localMap.set(lf.relPath, lf);
+      }
+      for (const [relPath, rInfo] of remoteMap.entries()) {
+        const lFile = localMap.get(relPath);
+        const shouldDownload = !lFile || rInfo.timestamp > lFile.mtimeMs + 2e3;
+        if (shouldDownload) {
+          const buf = await adapter.read(relPath);
+          const destPath = path.join(workingDir, relPath);
+          await fs.promises.mkdir(path.dirname(destPath), { recursive: true });
+          await fs.promises.writeFile(destPath, buf);
+          try {
+            const fileTime = new Date(rInfo.timestamp);
+            await fs.promises.utimes(destPath, fileTime, fileTime);
+          } catch {
+          }
+          syncedFiles.push({ fileName: relPath, action: "DOWNLOADED", sizeBytes: buf.byteLength });
+          downloadedCount++;
+        }
+      }
+      for (const [relPath, lFile] of localMap.entries()) {
+        const rInfo = remoteMap.get(relPath);
+        const shouldUpload = !rInfo || lFile.mtimeMs > rInfo.timestamp + 2e3;
+        if (shouldUpload) {
+          const content = await fs.promises.readFile(lFile.fullPath);
+          await adapter.write(relPath, new Uint8Array(content));
+          syncedFiles.push({ fileName: relPath, action: "UPLOADED", sizeBytes: lFile.sizeBytes });
+          uploadedCount++;
+        } else if (!syncedFiles.some((f) => f.fileName === relPath)) {
+          syncedFiles.push({ fileName: relPath, action: "UP_TO_DATE", sizeBytes: lFile.sizeBytes });
+        }
+      }
+      return {
+        success: true,
+        workspaceId,
+        folderKey,
+        workingDir,
+        persistenceType: "google_drive",
+        targetLocation: `GoogleDrive://${rootFolderId || "root"}`,
+        syncedFiles,
+        uploadedCount,
+        downloadedCount,
+        syncedAt: nowIso
+      };
+    } catch (err) {
+      return {
+        success: false,
+        workspaceId,
+        folderKey,
+        workingDir,
+        persistenceType: "google_drive",
+        targetLocation: `GoogleDrive://${rootFolderId || "root"}`,
+        syncedFiles,
+        uploadedCount,
+        downloadedCount,
+        syncedAt: nowIso,
+        error: err.message || "Google Drive sync failed."
+      };
+    }
+  }
   const vaultDir = path.resolve(process.cwd(), folderKey);
   await fs.promises.mkdir(vaultDir, { recursive: true });
   try {
@@ -505,8 +534,8 @@ var WorkingWorkspaceService = class {
   }
   workingDirResolver;
   type = "working";
-  getWorkingDir() {
-    return this.workingDirResolver ? this.workingDirResolver() : getWorkingWorkspaceDir();
+  getWorkingDir(workspaceId) {
+    return this.workingDirResolver ? this.workingDirResolver(workspaceId) : getWorkingWorkspaceDir(workspaceId);
   }
   async findWorkspace(workspaceId, env) {
     return await findUserWorkspace(workspaceId, env);
@@ -516,7 +545,7 @@ var WorkingWorkspaceService = class {
   }
   async createWorkspace(userId, data, env) {
     const res = await createWorkspace(userId, data, env);
-    const dir = this.getWorkingDir();
+    const dir = this.getWorkingDir(res.workspace?.id || data?.id || "default");
     try {
       await fs2.promises.mkdir(dir, { recursive: true });
     } catch {
@@ -531,12 +560,12 @@ var WorkingWorkspaceService = class {
   }
   async readFile(_workspaceId, filePath) {
     const cleanRel = filePath.replace(/^\/+/, "");
-    const fullPath = path2.resolve(this.getWorkingDir(), cleanRel);
+    const fullPath = path2.resolve(this.getWorkingDir(_workspaceId), cleanRel);
     return await fs2.promises.readFile(fullPath);
   }
   async writeFile(_workspaceId, filePath, content) {
     const cleanRel = filePath.replace(/^\/+/, "");
-    const fullPath = path2.resolve(this.getWorkingDir(), cleanRel);
+    const fullPath = path2.resolve(this.getWorkingDir(_workspaceId), cleanRel);
     await fs2.promises.mkdir(path2.dirname(fullPath), { recursive: true });
     const buffer = typeof content === "string" ? Buffer.from(content) : Buffer.from(content.buffer, content.byteOffset, content.byteLength);
     await fs2.promises.writeFile(fullPath, buffer);
@@ -544,7 +573,7 @@ var WorkingWorkspaceService = class {
   }
   async deleteFile(_workspaceId, filePath) {
     const cleanRel = filePath.replace(/^\/+/, "");
-    const fullPath = path2.resolve(this.getWorkingDir(), cleanRel);
+    const fullPath = path2.resolve(this.getWorkingDir(_workspaceId), cleanRel);
     try {
       await fs2.promises.unlink(fullPath);
       return { success: true };
@@ -553,7 +582,7 @@ var WorkingWorkspaceService = class {
     }
   }
   async listFiles(_workspaceId, subfolder = "") {
-    const baseDir = path2.resolve(this.getWorkingDir(), subfolder.replace(/^\/+/, ""));
+    const baseDir = path2.resolve(this.getWorkingDir(_workspaceId), subfolder.replace(/^\/+/, ""));
     if (!fs2.existsSync(baseDir)) return [];
     const entries = await fs2.promises.readdir(baseDir, { withFileTypes: true });
     return entries.map((e) => {
@@ -567,7 +596,7 @@ var WorkingWorkspaceService = class {
       } catch {
       }
       return {
-        path: path2.relative(this.getWorkingDir(), full),
+        path: path2.relative(this.getWorkingDir(_workspaceId), full),
         name: e.name,
         isFolder: e.isDirectory(),
         sizeBytes,
@@ -581,12 +610,46 @@ var WorkingWorkspaceService = class {
 };
 var workingWorkspaceService = new WorkingWorkspaceService();
 
+// src/workspace/RemoteWorkspaceService.ts
+var RemoteWorkspaceService = class {
+  type = "working";
+  findWorkspace(id, env) {
+    return workingWorkspaceService.findWorkspace(id, env);
+  }
+  listWorkspaces(userId, env) {
+    return workingWorkspaceService.listWorkspaces(userId, env);
+  }
+  createWorkspace(userId, data, env) {
+    return workingWorkspaceService.createWorkspace(userId, data, env);
+  }
+  updateWorkspace(userId, params, env) {
+    return workingWorkspaceService.updateWorkspace(userId, params, env);
+  }
+  deleteWorkspace(userId, id, env) {
+    return workingWorkspaceService.deleteWorkspace(userId, id, env);
+  }
+  readFile(id, path3, env) {
+    return workingWorkspaceService.readFile(id, path3);
+  }
+  writeFile(id, path3, content, env) {
+    return workingWorkspaceService.writeFile(id, path3, content);
+  }
+  deleteFile(id, path3, env) {
+    return workingWorkspaceService.deleteFile(id, path3);
+  }
+  listFiles(id, subfolder, env) {
+    return workingWorkspaceService.listFiles(id, subfolder);
+  }
+  sync(id, options, env) {
+    return workingWorkspaceService.sync(id, options);
+  }
+};
+var remoteWorkspaceService = workingWorkspaceService;
+
 export {
   WorkspaceFS,
   SyncEngine,
   WorkspaceCloneSyncEngine,
-  RemoteWorkspaceService,
-  remoteWorkspaceService,
   getDefaultWorkingWorkspaceDir,
   getWorkingWorkspaceConfig,
   setWorkingWorkspaceConfig,
@@ -595,5 +658,7 @@ export {
   getWorkspaceFolderKey,
   syncWorkspace,
   WorkingWorkspaceService,
-  workingWorkspaceService
+  workingWorkspaceService,
+  RemoteWorkspaceService,
+  remoteWorkspaceService
 };

package/packages/backend/dist/{chunk-MPYASJ5A.js → chunk-HT2SEDHD.js}

@@ -1,7 +1,7 @@
 import {
   RateLimiter,
   SessionManager
-} from "./chunk-ZDH4XI7W.js";
+} from "./chunk-M4GSR46Y.js";
 
 // src/auth/PasswordHasher.ts
 var bcrypt = null;