@arch-cadre/core 0.0.42 → 0.0.43

package/dist/core/auth/utils/{encryption.d.mts → encryption.d.ts}

@@ -1,28 +1,25 @@
-//#region src/core/auth/utils/encryption.d.ts
 /**
  * Encrypts data using AES-128-GCM.
  * @param data Data to be encrypted.
  * @returns Encrypted data including IV and auth tag.
  */
-declare function encrypt(data: Uint8Array): Uint8Array;
+export declare function encrypt(data: Uint8Array): Uint8Array;
 /**
  * Encrypts a string.
  * @param data String to be encrypted.
  * @returns Encrypted data as Uint8Array.
  */
-declare function encryptString(data: string): Uint8Array;
+export declare function encryptString(data: string): Uint8Array;
 /**
  * Decrypts data using AES-128-GCM.
  * @param encrypted Encrypted data (IV + content + auth tag).
  * @returns Decrypted data.
  */
-declare function decrypt(encrypted: Uint8Array): Uint8Array;
+export declare function decrypt(encrypted: Uint8Array): Uint8Array;
 /**
  * Decrypts data to a string.
  * @param data Encrypted data.
  * @returns Odszyfrowany ciąg znaków.
  */
-declare function decryptToString(data: Uint8Array): string;
-//#endregion
-export { decrypt, decryptToString, encrypt, encryptString };
-//# sourceMappingURL=encryption.d.mts.map
+export declare function decryptToString(data: Uint8Array): string;
+//# sourceMappingURL=encryption.d.ts.map

package/dist/core/auth/utils/encryption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encryption.d.ts","sourceRoot":"","sources":["../../../../src/core/auth/utils/encryption.ts"],"names":[],"mappings":"AAeA;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAUpD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAEtD;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,SAAS,EAAE,UAAU,GAAG,UAAU,CAezD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAExD"}

package/dist/core/auth/utils/encryption.js

@@ -0,0 +1,62 @@
+import { createCipheriv, createDecipheriv } from "node:crypto";
+import { DynamicBuffer } from "@oslojs/binary";
+import { decodeBase64 } from "@oslojs/encoding";
+const ENCRYPTION_KEY = process.env.ENCRYPTION_KEY;
+if (!ENCRYPTION_KEY) {
+    throw new Error("ENCRYPTION_KEY environment variable is not set");
+}
+/**
+ * The encryption key decoded from base64.
+ */
+const key = decodeBase64(ENCRYPTION_KEY);
+/**
+ * Encrypts data using AES-128-GCM.
+ * @param data Data to be encrypted.
+ * @returns Encrypted data including IV and auth tag.
+ */
+export function encrypt(data) {
+    const iv = new Uint8Array(16);
+    crypto.getRandomValues(iv);
+    const cipher = createCipheriv("aes-128-gcm", key, iv);
+    const encrypted = new DynamicBuffer(0);
+    encrypted.write(iv);
+    encrypted.write(cipher.update(data));
+    encrypted.write(cipher.final());
+    encrypted.write(cipher.getAuthTag());
+    return encrypted.bytes();
+}
+/**
+ * Encrypts a string.
+ * @param data String to be encrypted.
+ * @returns Encrypted data as Uint8Array.
+ */
+export function encryptString(data) {
+    return encrypt(new TextEncoder().encode(data));
+}
+/**
+ * Decrypts data using AES-128-GCM.
+ * @param encrypted Encrypted data (IV + content + auth tag).
+ * @returns Decrypted data.
+ */
+export function decrypt(encrypted) {
+    if (encrypted.byteLength < 33) {
+        throw new Error("Invalid encrypted data length");
+    }
+    const iv = encrypted.slice(0, 16);
+    const authTag = encrypted.slice(encrypted.byteLength - 16);
+    const content = encrypted.slice(16, encrypted.byteLength - 16);
+    const decipher = createDecipheriv("aes-128-gcm", key, iv);
+    decipher.setAuthTag(authTag);
+    const decrypted = new DynamicBuffer(0);
+    decrypted.write(decipher.update(content));
+    decrypted.write(decipher.final());
+    return decrypted.bytes();
+}
+/**
+ * Decrypts data to a string.
+ * @param data Encrypted data.
+ * @returns Odszyfrowany ciąg znaków.
+ */
+export function decryptToString(data) {
+    return new TextDecoder().decode(decrypt(data));
+}

package/dist/core/auth/validation.d.ts

@@ -0,0 +1,44 @@
+import { z } from "zod";
+export declare const loginSchema: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+    remember: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const registerSchema: z.ZodObject<{
+    username: z.ZodString;
+    email: z.ZodString;
+    password: z.ZodString;
+    terms: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const forgotPasswordSchema: z.ZodObject<{
+    email: z.ZodString;
+}, z.core.$strip>;
+export declare const resetPasswordSchema: z.ZodObject<{
+    password: z.ZodString;
+    confirm: z.ZodString;
+}, z.core.$strip>;
+export declare const verifyEmailSchema: z.ZodObject<{
+    code: z.ZodString;
+}, z.core.$strip>;
+export declare const totpSetupSchema: z.ZodObject<{
+    code: z.ZodString;
+}, z.core.$strip>;
+export declare const totpVerifySchema: z.ZodObject<{
+    code: z.ZodString;
+}, z.core.$strip>;
+export declare const passkeysSetupSchema: z.ZodObject<{
+    name: z.ZodString;
+}, z.core.$strip>;
+export declare const recoveryCodeVerifySchema: z.ZodObject<{
+    code: z.ZodString;
+}, z.core.$strip>;
+export type LoginInput = z.infer<typeof loginSchema>;
+export type RegisterInput = z.infer<typeof registerSchema>;
+export type ForgotPasswordInput = z.infer<typeof forgotPasswordSchema>;
+export type ResetPasswordInput = z.infer<typeof resetPasswordSchema>;
+export type TOTPSetupInput = z.infer<typeof totpSetupSchema>;
+export type TOTPVerifyInput = z.infer<typeof totpVerifySchema>;
+export type PasskeysSetupInput = z.infer<typeof passkeysSetupSchema>;
+export type VerifyEmailInput = z.infer<typeof verifyEmailSchema>;
+export type RecoveryVerifyInput = z.infer<typeof recoveryCodeVerifySchema>;
+//# sourceMappingURL=validation.d.ts.map

package/dist/core/auth/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/core/auth/validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,WAAW;;;;iBAItB,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;iBAKzB,CAAC;AAEH,eAAO,MAAM,oBAAoB;;iBAE/B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;iBAQ5B,CAAC;AAEL,eAAO,MAAM,iBAAiB;;iBAE5B,CAAC;AAGH,eAAO,MAAM,eAAe;;iBAE1B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;iBAE3B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;iBAE9B,CAAC;AAEH,eAAO,MAAM,wBAAwB;;iBAEnC,CAAC;AAGH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AACrD,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAC3D,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AACvE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AACrE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAC7D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC/D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AACrE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AACjE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/dist/core/auth/validation.js

@@ -0,0 +1,41 @@
+import { z } from "zod";
+// Auth validation schemas - CLEAN (No DB dependencies for client-side)
+export const loginSchema = z.object({
+    email: z.string().email("Invalid email address"),
+    password: z.string().min(8),
+    remember: z.boolean().optional(),
+});
+export const registerSchema = z.object({
+    username: z.string().min(2, "Name must be at least 2 characters"),
+    email: z.string().email("Invalid email address"),
+    password: z.string().min(8, "Password must be at least 8 characters"),
+    terms: z.boolean().refine((val) => val === true, "You must accept the terms"),
+});
+export const forgotPasswordSchema = z.object({
+    email: z.string().email("Invalid email address"),
+});
+export const resetPasswordSchema = z
+    .object({
+    password: z.string().min(8, "Password must be at least 8 characters"),
+    confirm: z.string(),
+})
+    .refine((data) => data.password === data.confirm, {
+    message: "Passwords do not match",
+    path: ["confirm"],
+});
+export const verifyEmailSchema = z.object({
+    code: z.string().min(6).max(6),
+});
+// mfa validation schemas
+export const totpSetupSchema = z.object({
+    code: z.string().regex(/^\d{6}$/, "Code must be 6 digits"),
+});
+export const totpVerifySchema = z.object({
+    code: z.string().regex(/^\d{6}$/, "Code must be 6 digits"),
+});
+export const passkeysSetupSchema = z.object({
+    name: z.string().min(1, "Passkey name is required"),
+});
+export const recoveryCodeVerifySchema = z.object({
+    code: z.string().min(16, "Recovery code is required").max(16),
+});

package/dist/core/bootstrap.d.ts

@@ -0,0 +1,2 @@
+export declare function ensureSystemInitialized(providedDb?: any): Promise<void>;
+//# sourceMappingURL=bootstrap.d.ts.map

package/dist/core/bootstrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../src/core/bootstrap.ts"],"names":[],"mappings":"AAQA,wBAAsB,uBAAuB,CAAC,UAAU,CAAC,EAAE,GAAG,iBAoD7D"}

package/dist/core/bootstrap.js

@@ -0,0 +1,51 @@
+import { injectDb } from "../server/database/inject";
+import { initEmailVerification } from "./auth/email-verification";
+import { eventBus } from "./event-bus";
+import { filesystemService } from "./filesystem/index";
+import { LocalFileProvider } from "./filesystem/providers/local";
+import { notificationService } from "./notifications/service";
+import { isSystemInstalled } from "./setup";
+export async function ensureSystemInitialized(providedDb) {
+    if (typeof window !== "undefined")
+        return;
+    const g = globalThis;
+    // 1. Immediate injection if provided
+    if (providedDb) {
+        injectDb(providedDb);
+    }
+    // 2. Prevent infinite recursion and double initialization
+    if (g.__KRYO_INITIALIZED__)
+        return;
+    if (g.__KRYO_INITIALIZING__)
+        return; // Already in progress, don't block/deadlock
+    g.__KRYO_INITIALIZING__ = true;
+    try {
+        console.log("[Kryo:Bootstrap] Starting system initialization...");
+        // Check if we have DB after any possible injection
+        if (!g.__KRYO_DB__) {
+            console.warn("[Kryo:Bootstrap] DB not detected during bootstrap start. Trying to continue...");
+        }
+        // Check if system is installed before initializing modules
+        if (await isSystemInstalled()) {
+            // Order matters: services first, then modules (which use services)
+            notificationService.init();
+            await initEmailVerification();
+            // Auto-register local filesystem provider as a fallback
+            const local = new LocalFileProvider();
+            filesystemService.registerProvider(local);
+            filesystemService.setDefaultProvider(local.id);
+        }
+        else {
+            console.log("[Kryo:Bootstrap] System not installed. Skipping module initialization.");
+        }
+        await eventBus.publish("system:start", { runtime: "nodejs" });
+        console.log("[Kryo:Bootstrap] System initialized successfully.");
+        g.__KRYO_INITIALIZED__ = true;
+    }
+    catch (error) {
+        console.error("[Kryo:Bootstrap] Initialization failed:", error);
+    }
+    finally {
+        g.__KRYO_INITIALIZING__ = false;
+    }
+}

package/dist/core/config.d.ts

@@ -0,0 +1,9 @@
+export interface KryoConfig {
+    /**
+     * Path to the directory with local modules.
+     * Default: "./modules"
+     */
+    modulesDirectory?: string;
+}
+export declare const DEFAULT_CONFIG: KryoConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/core/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/core/config.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACzB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,eAAO,MAAM,cAAc,EAAE,UAE5B,CAAC"}

package/dist/core/config.js

@@ -0,0 +1,3 @@
+export const DEFAULT_CONFIG = {
+    modulesDirectory: "modules",
+};

package/dist/core/config.server.d.ts

@@ -0,0 +1,12 @@
+import { type KryoConfig } from "./config";
+/**
+ * Loads the Kryo configuration from kryo.config.ts or kryo.config in the current working directory.
+ * SERVER ONLY.
+ */
+export declare function getKryoConfig(): Promise<KryoConfig>;
+/**
+ * Helper returning the absolute path to the modules directory.
+ * SERVER ONLY.
+ */
+export declare function getModulesDir(): Promise<string>;
+//# sourceMappingURL=config.server.d.ts.map

package/dist/core/config.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.server.d.ts","sourceRoot":"","sources":["../../src/core/config.server.ts"],"names":[],"mappings":"AAEA,OAAO,EAAkB,KAAK,UAAU,EAAE,MAAM,UAAU,CAAC;AAI3D;;;GAGG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAAC,UAAU,CAAC,CAsDzD;AAED;;;GAGG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC,CAKrD"}

package/dist/core/config.server.js

@@ -0,0 +1,61 @@
+import fs from "node:fs";
+import path from "node:path";
+import { DEFAULT_CONFIG } from "./config";
+let cachedConfig = null;
+/**
+ * Loads the Kryo configuration from kryo.config.ts or kryo.config in the current working directory.
+ * SERVER ONLY.
+ */
+export async function getKryoConfig() {
+    // Prevent this from ever running on the client even if imported
+    if (typeof window !== "undefined") {
+        throw new Error("getKryoConfig can only be called on the server.");
+    }
+    // Use memory cache in production
+    if (process.env.NODE_ENV === "production" && cachedConfig) {
+        return cachedConfig;
+    }
+    const cwd = process.cwd();
+    const configPathTS = path.join(cwd, "kryo.config.ts");
+    const configPathJS = path.join(cwd, "kryo.config");
+    const configPathMJS = path.join(cwd, "kryo.config.mjs");
+    let loadedConfig = {};
+    try {
+        // Dynamic import jiti only on server to avoid bundling issues
+        const { createJiti } = await import("jiti");
+        const jiti = createJiti(cwd, {
+            fsCache: false,
+            moduleCache: false,
+        });
+        if (fs.existsSync(configPathTS)) {
+            const cacheBuster = `?t=${Date.now()}`;
+            const imported = await jiti.import(`file://${configPathTS}${cacheBuster}`, { default: true });
+            loadedConfig = imported.default || imported;
+        }
+        else if (fs.existsSync(configPathMJS)) {
+            const imported = await jiti.import(configPathMJS, { default: true });
+            loadedConfig = imported.default || imported;
+        }
+        else if (fs.existsSync(configPathJS)) {
+            const imported = await jiti.import(configPathJS, { default: true });
+            loadedConfig = imported.default || imported;
+        }
+    }
+    catch (error) {
+        console.warn("[Kryo:Config] Could not load kryo.config.ts, using defaults.", error);
+    }
+    const finalConfig = { ...DEFAULT_CONFIG, ...loadedConfig };
+    if (process.env.NODE_ENV === "production") {
+        cachedConfig = finalConfig;
+    }
+    return finalConfig;
+}
+/**
+ * Helper returning the absolute path to the modules directory.
+ * SERVER ONLY.
+ */
+export async function getModulesDir() {
+    const config = await getKryoConfig();
+    const dir = config.modulesDirectory || "modules";
+    return path.isAbsolute(dir) ? dir : path.join(process.cwd(), dir);
+}

package/dist/core/event-bus.d.ts

@@ -0,0 +1,14 @@
+import type { EventHandler } from "./types";
+/**
+ * EventBus (Pub/Sub) - Global Singleton Pattern.
+ */
+declare class EventBus {
+    private handlers;
+    subscribe<T>(eventType: string, subscriberId: string, handler: EventHandler<T>): void;
+    unsubscribe(eventType: string, subscriberId: string): void;
+    clearAll(): void;
+    publish<T>(eventType: string, payload: T, source?: string): Promise<void>;
+}
+export declare const eventBus: EventBus;
+export {};
+//# sourceMappingURL=event-bus.d.ts.map

package/dist/core/event-bus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-bus.d.ts","sourceRoot":"","sources":["../../src/core/event-bus.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAe,MAAM,SAAS,CAAC;AAEzD;;GAEG;AACH,cAAM,QAAQ;IACZ,OAAO,CAAC,QAAQ,CAAqD;IAE9D,SAAS,CAAC,CAAC,EAChB,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,GACvB,IAAI;IAWA,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI;IAO1D,QAAQ,IAAI,IAAI;IAKV,OAAO,CAAC,CAAC,EACpB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,CAAC,EACV,MAAM,GAAE,MAAiB,GACxB,OAAO,CAAC,IAAI,CAAC;CA2BjB;AAOD,eAAO,MAAM,QAAQ,UAAyD,CAAC"}

package/dist/core/event-bus.js

@@ -0,0 +1,51 @@
+var _a;
+/**
+ * EventBus (Pub/Sub) - Global Singleton Pattern.
+ */
+class EventBus {
+    constructor() {
+        this.handlers = new Map();
+    }
+    subscribe(eventType, subscriberId, handler) {
+        if (!this.handlers.has(eventType)) {
+            this.handlers.set(eventType, new Map());
+        }
+        const eventHandlers = this.handlers.get(eventType);
+        eventHandlers === null || eventHandlers === void 0 ? void 0 : eventHandlers.set(subscriberId, handler);
+        console.log(`[Event Bus] Subscriber "${subscriberId}" added for "${eventType}"`);
+    }
+    unsubscribe(eventType, subscriberId) {
+        var _a;
+        (_a = this.handlers.get(eventType)) === null || _a === void 0 ? void 0 : _a.delete(subscriberId);
+        console.log(`[Event Bus] Subscriber "${subscriberId}" removed from "${eventType}"`);
+    }
+    clearAll() {
+        console.log("[Event Bus] Resetting all listeners...");
+        this.handlers.clear();
+    }
+    async publish(eventType, payload, source = "system") {
+        const eventHandlers = this.handlers.get(eventType);
+        if (!eventHandlers)
+            return;
+        const handlers = Array.from(eventHandlers.values());
+        console.log(`[Event Bus] Publishing "${eventType}" to ${handlers.length} subscribers`);
+        const event = {
+            type: eventType,
+            payload,
+            timestamp: Date.now(),
+            source,
+        };
+        await Promise.all(handlers.map(async (handler) => {
+            try {
+                await handler(event);
+            }
+            catch (error) {
+                console.error(`[Event Bus] Handler Error for ${eventType}:`, error);
+            }
+        }));
+    }
+}
+// Ensure global singleton
+const globalForEventBus = globalThis;
+export const eventBus = (_a = globalForEventBus.__KRYO_EVENT_BUS__) !== null && _a !== void 0 ? _a : new EventBus();
+globalForEventBus.__KRYO_EVENT_BUS__ = eventBus;

package/dist/core/filesystem/index.d.ts

@@ -0,0 +1,4 @@
+import { filesystemService } from "./service";
+export * from "./types";
+export { filesystemService };
+//# sourceMappingURL=index.d.ts.map

package/dist/core/filesystem/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/filesystem/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAE9C,cAAc,SAAS,CAAC;AACxB,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/core/filesystem/index.js

@@ -0,0 +1,10 @@
+import { LocalFileProvider } from "./providers/local";
+import { filesystemService } from "./service";
+export * from "./types";
+export { filesystemService };
+// Auto-register local provider
+if (typeof window === "undefined") {
+    const local = new LocalFileProvider();
+    filesystemService.registerProvider(local);
+    filesystemService.setDefaultProvider(local.id);
+}

package/dist/core/filesystem/providers/local.d.ts

@@ -0,0 +1,8 @@
+import type { IStorageProvider, StorageResult } from "../types";
+export declare class LocalFileProvider implements IStorageProvider {
+    id: string;
+    name: string;
+    private generateUniqueImageName;
+    upload(file: File): Promise<StorageResult>;
+}
+//# sourceMappingURL=local.d.ts.map

package/dist/core/filesystem/providers/local.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local.d.ts","sourceRoot":"","sources":["../../../../src/core/filesystem/providers/local.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEhE,qBAAa,iBAAkB,YAAW,gBAAgB;IACjD,EAAE,SAAW;IACb,IAAI,SAAsB;IAEjC,OAAO,CAAC,uBAAuB;IAUlB,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,aAAa,CAAC;CA4BxD"}

package/dist/core/filesystem/providers/local.js

@@ -0,0 +1,42 @@
+import fs from "node:fs";
+import path from "node:path";
+export class LocalFileProvider {
+    constructor() {
+        this.id = "local";
+        this.name = "Local Filesystem";
+    }
+    generateUniqueImageName(name) {
+        const cleanName = name.replace(/\s+/g, "-").toLowerCase();
+        const suffix = Math.floor(Math.random() * Date.now()).toString(36);
+        const index = cleanName.lastIndexOf(".");
+        return index < 0
+            ? `${cleanName}-${suffix}`
+            : `${cleanName.slice(0, index)}-${suffix}${cleanName.slice(index)}`;
+    }
+    async upload(file) {
+        var _a;
+        try {
+            const storageFolder = (_a = process.env.FILE_STORAGE_FOLDER) !== null && _a !== void 0 ? _a : "public/storage";
+            if (!fs.existsSync(storageFolder)) {
+                fs.mkdirSync(storageFolder, { recursive: true });
+            }
+            const name = this.generateUniqueImageName(file.name);
+            const filePath = path.join(storageFolder, name);
+            const buffer = await file.arrayBuffer();
+            fs.writeFileSync(filePath, Buffer.from(buffer));
+            const url = `${storageFolder}/${name}`.replace("public", "");
+            return {
+                name: name,
+                url,
+                type: file.type,
+                size: file.size,
+                service: "local",
+                serviceId: filePath,
+            };
+        }
+        catch (error) {
+            console.error("Error uploading file", error);
+            return { error: "Error uploading file" };
+        }
+    }
+}

package/dist/core/filesystem/service.d.ts

@@ -0,0 +1,16 @@
+import type { IStorageProvider, StorageResult } from "./types";
+declare class FilesystemService {
+    private providers;
+    private defaultProviderId;
+    registerProvider(provider: IStorageProvider): void;
+    unregisterProvider(id: string): void;
+    setDefaultProvider(id: string): void;
+    upload(file: File, providerId?: string): Promise<StorageResult>;
+    getProviders(): {
+        id: string;
+        name: string;
+    }[];
+}
+export declare const filesystemService: FilesystemService;
+export {};
+//# sourceMappingURL=service.d.ts.map

package/dist/core/filesystem/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../src/core/filesystem/service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE/D,cAAM,iBAAiB;IACrB,OAAO,CAAC,SAAS,CAA4C;IAC7D,OAAO,CAAC,iBAAiB,CAAuB;IAEzC,gBAAgB,CAAC,QAAQ,EAAE,gBAAgB;IAQ3C,kBAAkB,CAAC,EAAE,EAAE,MAAM;IAU7B,kBAAkB,CAAC,EAAE,EAAE,MAAM;IAOvB,MAAM,CAAC,IAAI,EAAE,IAAI,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAiBrE,YAAY;;;;CAMpB;AAOD,eAAO,MAAM,iBAAiB,mBAC8C,CAAC"}

package/dist/core/filesystem/service.js

@@ -0,0 +1,51 @@
+var _a;
+class FilesystemService {
+    constructor() {
+        this.providers = new Map();
+        this.defaultProviderId = null;
+    }
+    registerProvider(provider) {
+        this.providers.set(provider.id, provider);
+        if (!this.defaultProviderId || this.defaultProviderId === "local") {
+            this.defaultProviderId = provider.id;
+        }
+        console.log(`[Filesystem] Provider registered: ${provider.id}`);
+    }
+    unregisterProvider(id) {
+        this.providers.delete(id);
+        if (this.defaultProviderId === id) {
+            this.defaultProviderId = this.providers.has("local")
+                ? "local"
+                : Array.from(this.providers.keys())[0] || null;
+        }
+        console.log(`[Filesystem] Provider unregistered: ${id}`);
+    }
+    setDefaultProvider(id) {
+        if (this.providers.has(id)) {
+            this.defaultProviderId = id;
+            console.log(`[Filesystem] Default provider set to: ${id}`);
+        }
+    }
+    async upload(file, providerId) {
+        let id = providerId || this.defaultProviderId;
+        // Fallback logic
+        if (!id || !this.providers.has(id)) {
+            id = "local";
+        }
+        const provider = this.providers.get(id);
+        if (!provider) {
+            return { error: "No storage provider available (local fallback failed)" };
+        }
+        return await provider.upload(file);
+    }
+    getProviders() {
+        return Array.from(this.providers.values()).map((p) => ({
+            id: p.id,
+            name: p.name,
+        }));
+    }
+}
+// Global Singleton Pattern
+const globalForFilesystem = globalThis;
+export const filesystemService = (_a = globalForFilesystem.__KRYO_FILESYSTEM_SERVICE__) !== null && _a !== void 0 ? _a : new FilesystemService();
+globalForFilesystem.__KRYO_FILESYSTEM_SERVICE__ = filesystemService;

package/dist/core/filesystem/types.d.ts

@@ -0,0 +1,19 @@
+export interface StorageData {
+    name: string;
+    url: string;
+    type: string;
+    size: number;
+    service: string;
+    serviceId: string;
+}
+export interface StorageError {
+    error: string;
+}
+export type StorageResult = StorageData | StorageError;
+export interface IStorageProvider {
+    id: string;
+    name: string;
+    upload(file: File, options?: any): Promise<StorageResult>;
+    delete?(serviceId: string): Promise<boolean>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/filesystem/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/core/filesystem/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,MAAM,aAAa,GAAG,WAAW,GAAG,YAAY,CAAC;AAEvD,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;IAC1D,MAAM,CAAC,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC9C"}

package/dist/core/filesystem/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/notifications/actions.d.ts

@@ -0,0 +1,54 @@
+import type { CreateNotificationPayload } from "./types";
+export declare function getUserNotifications(): Promise<{
+    id: string;
+    title: string;
+    content: string | null;
+    target: string | null;
+    type: string | null;
+    isRead: boolean;
+    resourceId: string | null;
+    resourceType: string | null;
+    userId: string;
+    createdAt: Date;
+    updatedAt: Date | null;
+}[] | null>;
+export declare function createNotification(data: CreateNotificationPayload): Promise<{
+    id: string;
+    createdAt: Date;
+    updatedAt: Date | null;
+    userId: string;
+    title: string;
+    content: string | null;
+    target: string | null;
+    type: string | null;
+    isRead: boolean;
+    resourceId: string | null;
+    resourceType: string | null;
+}>;
+export declare function markNotificationAsRead(id: string): Promise<{
+    id: string;
+    title: string;
+    content: string | null;
+    target: string | null;
+    type: string | null;
+    isRead: boolean;
+    resourceId: string | null;
+    resourceType: string | null;
+    userId: string;
+    createdAt: Date;
+    updatedAt: Date | null;
+}>;
+export declare function markAllNotificationsAsRead(): Promise<{
+    id: string;
+    title: string;
+    content: string | null;
+    target: string | null;
+    type: string | null;
+    isRead: boolean;
+    resourceId: string | null;
+    resourceType: string | null;
+    userId: string;
+    createdAt: Date;
+    updatedAt: Date | null;
+}[] | null>;
+//# sourceMappingURL=actions.d.ts.map

package/dist/core/notifications/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../../src/core/notifications/actions.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAEzD,wBAAsB,oBAAoB;;;;;;;;;;;;YASzC;AAED,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,yBAAyB;;;;;;;;;;;;GAUvE;AAED,wBAAsB,sBAAsB,CAAC,EAAE,EAAE,MAAM;;;;;;;;;;;;GAQtD;AAED,wBAAsB,0BAA0B;;;;;;;;;;;;YAS/C"}