@archlast/server 0.0.1

package/dist/deployment/handler.js

@@ -0,0 +1,1437 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeploymentHandler = void 0;
+const persistence_js_1 = require("./persistence.js");
+const logger_js_1 = require("../logging/logger.js");
+const function_extractor_js_1 = require("./function-extractor.js");
+const schema_js_1 = require("../auth/system/schema.js");
+const definition_js_1 = require("../functions/definition.js");
+const deployment_events_controller_js_1 = require("../controllers/deployment-events.controller.js");
+class DeploymentHandler {
+    uploadedFunctions = new Map();
+    uploadedHttpRoutes = new Map();
+    uploadedRpcRoutes = new Map();
+    uploadedSchema = null;
+    engine;
+    db;
+    persistence;
+    httpRouter = null;
+    rpcRouter = null; // Will be initialized as RpcRouter
+    deploymentLock = false;
+    constructor(engine, db) {
+        this.engine = engine;
+        this.db = db;
+        this.persistence = new persistence_js_1.DeploymentPersistence();
+    }
+    /**
+     * Acquire deployment lock
+     */
+    async acquireLock() {
+        if (this.deploymentLock) {
+            return false;
+        }
+        this.deploymentLock = true;
+        return true;
+    }
+    /**
+     * Release deployment lock
+     */
+    releaseLock() {
+        this.deploymentLock = false;
+    }
+    /**
+     * Set the HTTP router for registering user-defined routes
+     */
+    setHttpRouter(router) {
+        this.httpRouter = router;
+    }
+    async initialize() {
+        const state = await this.persistence.load();
+        if (state) {
+            await this.restoreDeployment(state);
+        }
+    }
+    async restoreDeployment(state) {
+        try {
+            const { join } = await import("path");
+            const fs = await import("fs/promises");
+            const deployDir = join(process.cwd(), ".archlast-deploy");
+            // Ensure deploy directory exists
+            await fs.mkdir(deployDir, { recursive: true });
+            // Write all files with directory structure preserved
+            for (const file of state.files) {
+                const filePath = join(deployDir, file.filePath);
+                const fileDir = join(filePath, "..");
+                await fs.mkdir(fileDir, { recursive: true });
+                // Rewrite imports for files in src/, keep others as-is
+                const code = file.filePath.startsWith("src/")
+                    ? await this.rewriteImports(file.code)
+                    : file.code;
+                await Bun.write(filePath, code);
+            }
+            // Load schema and functions
+            let restoredCount = 0;
+            // Check for static tRPC router (Phase 4: prioritize static router over dynamic registry)
+            const trpcRouterFile = state.files.find((f) => f.filePath.endsWith("_generated/trpc-router.ts") ||
+                f.filePath.endsWith("_generated/trpc-router.js"));
+            if (trpcRouterFile) {
+                try {
+                    const routerPath = join(deployDir, trpcRouterFile.filePath);
+                    const routerMod = await import(routerPath + `?t=${Date.now()}`);
+                    if (routerMod && routerMod.appRouter) {
+                        this.rpcRouter = routerMod.appRouter;
+                        logger_js_1.logger.log({
+                            timestamp: Date.now(),
+                            level: "info",
+                            kind: "deployment",
+                            message: "[Restore] Loaded static tRPC appRouter from trpc-router.ts",
+                        });
+                    }
+                }
+                catch (err) {
+                    logger_js_1.logger.log({
+                        timestamp: Date.now(),
+                        level: "error",
+                        kind: "deployment",
+                        message: "[Restore] Failed to load static tRPC router:",
+                        context: { err },
+                    });
+                }
+            }
+            // First, look for DI registration
+            const diFile = state.files.find((f) => f.filePath.endsWith("_generated/di.ts") ||
+                f.filePath.endsWith("_generated/di.js"));
+            if (diFile) {
+                try {
+                    const diPath = join(deployDir, diFile.filePath);
+                    const diMod = await import(diPath + `?t=${Date.now()}`);
+                    if (diMod && typeof diMod.registerProviders === "function") {
+                        const { globalContainer } = await import("../di/container.js");
+                        diMod.registerProviders(globalContainer);
+                        logger_js_1.logger.log({
+                            timestamp: Date.now(),
+                            level: "info",
+                            kind: "deployment",
+                            message: `[Restore] Registered DI providers from ${diFile.filePath}`,
+                        });
+                    }
+                }
+                catch (err) {
+                    logger_js_1.logger.log({
+                        timestamp: Date.now(),
+                        level: "error",
+                        kind: "deployment",
+                        message: "[Restore] Failed to register DI providers:",
+                        context: { err },
+                    });
+                }
+            }
+            for (const file of state.files) {
+                const fullPath = join(deployDir, file.filePath);
+                const fileName = file.filePath.split(/[\\/]/).pop() || "unknown.ts";
+                const moduleName = fileName.replace(/\.(ts|js)$/, "");
+                // Load schema
+                if (file.filePath.endsWith("schema.ts")) {
+                    const mod = await import(fullPath + `?t=${Date.now()}`);
+                    if (mod.default && mod.default.tables) {
+                        const mergedSchema = {
+                            ...mod.default,
+                            tables: {
+                                ...(mod.default.tables ?? {}),
+                                ...schema_js_1.authSchema.tables,
+                            },
+                        };
+                        this.uploadedSchema = mergedSchema;
+                        await this.db.applySchema(mergedSchema);
+                    }
+                    continue;
+                }
+                // Load functions and routes
+                const hasFunctions = /export\s+(?:const|let)\s+\w+\s*=\s*(?:query|mutation|action|http\.\w+|webhook|rpc\.\w+|t\.router)\s*\(/g.test(file.code);
+                if (hasFunctions) {
+                    const mod = await import(fullPath + `?t=${Date.now()}`);
+                    for (const [key, value] of Object.entries(mod)) {
+                        // Check for HTTP route definitions
+                        if ((0, definition_js_1.isHttpDefinition)(value)) {
+                            const routeKey = `${moduleName}:${key}`;
+                            this.uploadedHttpRoutes.set(routeKey, value);
+                            if (this.httpRouter) {
+                                this.httpRouter.register(value);
+                            }
+                            continue;
+                        }
+                        // Check for webhook definitions
+                        if ((0, definition_js_1.isWebhookDefinition)(value)) {
+                            const routeKey = `${moduleName}:${key}`;
+                            this.uploadedHttpRoutes.set(routeKey, value);
+                            if (this.httpRouter) {
+                                this.httpRouter.register(value);
+                            }
+                            continue;
+                        }
+                        // Check for RPC definitions
+                        if ((0, definition_js_1.isRpcDefinition)(value)) {
+                            const routeKey = `${moduleName}:${key}`;
+                            this.uploadedRpcRoutes.set(routeKey, value);
+                            if (this.rpcRouter && typeof this.rpcRouter.register === 'function') {
+                                this.rpcRouter.register(moduleName, key, value);
+                            }
+                            continue;
+                        }
+                        // Check for generated appRouter (tRPC static router)
+                        if (key === "appRouter" && value && typeof value === "object") {
+                            this.rpcRouter = value;
+                            logger_js_1.logger.log({
+                                timestamp: Date.now(),
+                                level: "info",
+                                kind: "deployment",
+                                message: `[Restore] Registered static tRPC router (AppRouter)`,
+                            });
+                            continue;
+                        }
+                        // Check for query/mutation/action functions
+                        if (value &&
+                            typeof value === "object" &&
+                            "type" in value &&
+                            "handler" in value) {
+                            const fnName = `${moduleName}.${key}`;
+                            this.engine.registerFunction(fnName, value);
+                            this.uploadedFunctions.set(`${moduleName}:${key}`, {
+                                name: key,
+                                type: value.type,
+                                filePath: fullPath,
+                                fullName: fnName,
+                                // Preserve args schema (ZodObject) if provided by query/mutation config.
+                                args: value.args,
+                                timestamp: Date.now(),
+                            });
+                            restoredCount++;
+                        }
+                    }
+                }
+            }
+            // restoredCount can be surfaced via logger if needed
+        }
+        catch (error) {
+            // swallow to avoid noisy console logs during restore
+        }
+    }
+    async handleDeploy(payload) {
+        // Acquire deployment lock
+        if (!(await this.acquireLock())) {
+            return {
+                success: false,
+                message: "Deployment in progress, please wait",
+                functions: 0,
+                schema: false,
+            };
+        }
+        try {
+            // Validate payload
+            if (!payload || !Array.isArray(payload.files)) {
+                throw new Error("Invalid payload: 'files' array is missing or invalid");
+            }
+            const { join } = await import("path");
+            const fs = await import("fs/promises");
+            const deployDir = join(process.cwd(), ".archlast-deploy");
+            // Calculate file hash for diff detection
+            const fileHashes = new Map();
+            let filesHashStr = "";
+            payload.files.sort((a, b) => a.filePath.localeCompare(b.filePath));
+            for (const file of payload.files) {
+                const hash = this.hashString(file.code);
+                fileHashes.set(file.filePath, hash);
+                filesHashStr += `${file.filePath}:${hash};`;
+            }
+            const overallHash = this.hashString(filesHashStr);
+            // Load current state and check for changes
+            const currentState = await this.persistence.load();
+            const hasChanges = this.hasFileChanges(currentState, payload.files);
+            let functionCount = 0;
+            const schemaFile = payload.files.find((f) => f.filePath.endsWith("schema.ts"));
+            const hasSchema = !!schemaFile;
+            // Count functions in payload
+            for (const file of payload.files) {
+                if (file.code.includes("query(") ||
+                    file.code.includes("mutation(") ||
+                    file.code.includes("action(")) {
+                    functionCount++;
+                }
+            }
+            if (!hasChanges && currentState) {
+                await this.persistence.saveHistory({ files: payload.files, lastDeployment: payload.timestamp }, {
+                    timestamp: payload.timestamp,
+                    functionCount,
+                    schemaChanged: false, // No changes at all
+                    hash: overallHash,
+                });
+                return {
+                    success: true,
+                    message: "No changes detected",
+                    functions: functionCount,
+                    schema: hasSchema,
+                };
+            }
+            // Clear old registrations before loading new ones
+            this.uploadedFunctions.clear();
+            this.uploadedHttpRoutes.clear();
+            this.uploadedSchema = null;
+            if (this.httpRouter) {
+                this.httpRouter.clear();
+            }
+            // Ensure deploy directory exists
+            await fs.mkdir(deployDir, { recursive: true });
+            // Delete files that are no longer in the incoming payload
+            const incomingPaths = new Set(payload.files.map((f) => f.filePath));
+            if (currentState && currentState.files.length > 0) {
+                const filesToDelete = [];
+                for (const file of currentState.files) {
+                    if (!incomingPaths.has(file.filePath)) {
+                        filesToDelete.push(file.filePath);
+                    }
+                }
+                // Delete stale files
+                for (const filePath of filesToDelete) {
+                    const fullPath = join(deployDir, filePath);
+                    try {
+                        await fs.rm(fullPath, { force: true });
+                        logger_js_1.logger.log({
+                            timestamp: Date.now(),
+                            level: "info",
+                            kind: "deployment",
+                            message: `Deleted stale file: ${filePath}`,
+                        });
+                    }
+                    catch (err) {
+                        logger_js_1.logger.log({
+                            timestamp: Date.now(),
+                            level: "warn",
+                            kind: "deployment",
+                            message: `Failed to delete stale file: ${filePath}`,
+                            context: { err },
+                        });
+                    }
+                }
+                // Clean up empty directories
+                await this.cleanEmptyDirs(deployDir);
+            }
+            // Write all files with directory structure preserved
+            for (const file of payload.files) {
+                const filePath = join(deployDir, file.filePath);
+                const fileDir = join(filePath, "..");
+                await fs.mkdir(fileDir, { recursive: true });
+                // Rewrite imports for files in src/, keep others as-is
+                const code = file.filePath.startsWith("src/")
+                    ? await this.rewriteImports(file.code)
+                    : file.code;
+                await Bun.write(filePath, code);
+            }
+            // Scan and load files that contain functions or schema
+            const filesToLoad = [];
+            for (const file of payload.files) {
+                const fullPath = join(deployDir, file.filePath);
+                const fileName = file.filePath.split(/[\\/]/).pop() || "unknown.ts";
+                const moduleName = fileName.replace(/\.(ts|js)$/, "");
+                // Check if file is schema
+                if (file.filePath.endsWith("schema.ts")) {
+                    filesToLoad.push({ moduleName: "schema", filePath: fullPath, isSchema: true });
+                    continue;
+                }
+                // Check if file contains functions or HTTP routes
+                const hasFunctions = /export\s+(?:const|let)\s+\w+\s*=\s*(?:query|mutation|action|http\.(?:get|post|put|patch|delete)|webhook|t\.router)\s*\(/g.test(file.code);
+                if (hasFunctions) {
+                    filesToLoad.push({ moduleName, filePath: fullPath, isSchema: false });
+                }
+            }
+            // Load and register functions
+            let functionsRegistered = 0;
+            let schemaApplied = false;
+            // First, look for DI registration
+            const diFile = payload.files.find((f) => f.filePath.endsWith("_generated/di.ts") ||
+                f.filePath.endsWith("_generated/di.js"));
+            if (diFile) {
+                try {
+                    const diPath = join(deployDir, diFile.filePath);
+                    const diMod = await import(diPath + `?t=${Date.now()}`);
+                    if (diMod && typeof diMod.registerProviders === "function") {
+                        const { globalContainer } = await import("../di/container.js");
+                        diMod.registerProviders(globalContainer);
+                        logger_js_1.logger.log({
+                            timestamp: Date.now(),
+                            level: "info",
+                            kind: "deployment",
+                            message: `Registered DI providers from ${diFile.filePath}`,
+                        });
+                    }
+                }
+                catch (err) {
+                    logger_js_1.logger.log({
+                        timestamp: Date.now(),
+                        level: "error",
+                        kind: "deployment",
+                        message: "Failed to register DI providers:",
+                        context: { err },
+                    });
+                }
+            }
+            // Check for static tRPC router (Phase 4: prioritize static router over dynamic registry)
+            const trpcRouterFile = payload.files.find((f) => f.filePath.endsWith("_generated/trpc-router.ts") ||
+                f.filePath.endsWith("_generated/trpc-router.js"));
+            if (trpcRouterFile) {
+                try {
+                    const routerPath = join(deployDir, trpcRouterFile.filePath);
+                    const routerMod = await import(routerPath + `?t=${Date.now()}`);
+                    if (routerMod && routerMod.appRouter) {
+                        this.rpcRouter = routerMod.appRouter;
+                        logger_js_1.logger.log({
+                            timestamp: Date.now(),
+                            level: "info",
+                            kind: "deployment",
+                            message: "Loaded static tRPC appRouter from trpc-router.ts",
+                        });
+                    }
+                }
+                catch (err) {
+                    logger_js_1.logger.log({
+                        timestamp: Date.now(),
+                        level: "error",
+                        kind: "deployment",
+                        message: "Failed to load static tRPC router:",
+                        context: { err },
+                    });
+                }
+            }
+            for (const { moduleName, filePath, isSchema } of filesToLoad) {
+                const mod = await import(filePath + `?t=${Date.now()}`);
+                if (isSchema) {
+                    if (mod.default && mod.default.tables) {
+                        const mergedSchema = {
+                            ...mod.default,
+                            tables: {
+                                ...(mod.default.tables ?? {}),
+                                ...schema_js_1.authSchema.tables,
+                            },
+                        };
+                        this.uploadedSchema = mergedSchema;
+                        await this.db.applySchema(mergedSchema);
+                        schemaApplied = true;
+                    }
+                }
+                else {
+                    // Register all exported functions, HTTP routes, webhooks, and RPC procedures
+                    for (const [key, value] of Object.entries(mod)) {
+                        // Check for HTTP route definitions
+                        if ((0, definition_js_1.isHttpDefinition)(value)) {
+                            const routeKey = `${moduleName}:${key}`;
+                            this.uploadedHttpRoutes.set(routeKey, value);
+                            if (this.httpRouter) {
+                                this.httpRouter.register(value);
+                                logger_js_1.logger.log({
+                                    timestamp: Date.now(),
+                                    level: "info",
+                                    kind: "deployment",
+                                    message: `Registered HTTP route: ${value.method} ${value.path}`,
+                                });
+                            }
+                            continue;
+                        }
+                        // Check for webhook definitions
+                        if ((0, definition_js_1.isWebhookDefinition)(value)) {
+                            const routeKey = `${moduleName}:${key}`;
+                            this.uploadedHttpRoutes.set(routeKey, value);
+                            if (this.httpRouter) {
+                                this.httpRouter.register(value);
+                                logger_js_1.logger.log({
+                                    timestamp: Date.now(),
+                                    level: "info",
+                                    kind: "deployment",
+                                    message: `Registered webhook: ${value.method ?? "POST"} ${value.path}`,
+                                });
+                            }
+                            continue;
+                        }
+                        // Check for RPC definitions
+                        if ((0, definition_js_1.isRpcDefinition)(value)) {
+                            const routeKey = `${moduleName}:${key}`;
+                            this.uploadedRpcRoutes.set(routeKey, value);
+                            if (this.rpcRouter && typeof this.rpcRouter.register === 'function') {
+                                this.rpcRouter.register(moduleName, key, value);
+                                logger_js_1.logger.log({
+                                    timestamp: Date.now(),
+                                    level: "info",
+                                    kind: "deployment",
+                                    message: `Registered RPC procedure: ${moduleName}.${key} (${value.procedureType})`,
+                                });
+                            }
+                            continue;
+                        }
+                        // Check for generated appRouter (tRPC static router)
+                        if (key === "appRouter" && value && typeof value === "object") {
+                            this.rpcRouter = value;
+                            logger_js_1.logger.log({
+                                timestamp: Date.now(),
+                                level: "info",
+                                kind: "deployment",
+                                message: `Registered static tRPC router (AppRouter)`,
+                            });
+                            continue;
+                        }
+                        // Check for query/mutation/action functions
+                        if (value &&
+                            typeof value === "object" &&
+                            "type" in value &&
+                            "handler" in value) {
+                            const fnName = `${moduleName}.${key}`;
+                            this.engine.registerFunction(fnName, value);
+                            this.uploadedFunctions.set(`${moduleName}:${key}`, {
+                                name: key,
+                                type: value.type,
+                                filePath: filePath,
+                                fullName: fnName,
+                                // Preserve args schema (ZodObject) if provided by query/mutation config.
+                                args: value.args,
+                                timestamp: payload.timestamp,
+                            });
+                            functionsRegistered++;
+                        }
+                    }
+                }
+            }
+            // Extract function and schema metadata for smart pull
+            const metadata = this.extractDeploymentMetadata(payload.files, payload.timestamp);
+            // Save deployment state and history with metadata
+            const newState = {
+                files: payload.files,
+                lastDeployment: payload.timestamp,
+                functions: metadata.functions,
+                schema: metadata.schema,
+            };
+            await this.persistence.save(newState);
+            await this.persistence.saveHistory(newState, {
+                timestamp: payload.timestamp,
+                functionCount: functionsRegistered,
+                schemaChanged: schemaApplied, // Approximation
+                hash: overallHash,
+            });
+            // Broadcast deployment notification
+            try {
+                const { broadcastNotification } = await import("../functions/built-in/system-notifications.js");
+                broadcastNotification({
+                    title: "Deployment Complete",
+                    description: `${functionsRegistered} function(s) deployed${schemaApplied ? ", schema updated" : ""}`,
+                    type: "success",
+                    data: {
+                        functionCount: functionsRegistered,
+                        schemaChanged: schemaApplied,
+                        timestamp: payload.timestamp,
+                    },
+                });
+            }
+            catch (err) {
+                // Ignore notification errors
+                logger_js_1.logger.log({
+                    timestamp: Date.now(),
+                    level: "warn",
+                    kind: "deployment",
+                    message: "Failed to broadcast deployment notification:",
+                    context: { err },
+                });
+            }
+            // Emit deployment complete event for reactive CLI
+            (0, deployment_events_controller_js_1.emitDeploymentComplete)("full");
+            setTimeout(() => {
+                logger_js_1.logger.log({
+                    timestamp: Date.now(),
+                    level: "info",
+                    kind: "deployment",
+                    message: "Restarting server after deployment...",
+                });
+                process.exit(0);
+            }, 200);
+            return {
+                success: true,
+                message: "Deployment successful",
+                functions: functionsRegistered,
+                schema: schemaApplied,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: error instanceof Error ? error.message : "Unknown error",
+                functions: 0,
+                schema: false,
+            };
+        }
+        finally {
+            // Always release the lock
+            this.releaseLock();
+        }
+    }
+    async rewriteImports(code) {
+        const { join } = await import("path");
+        const deployDir = join(process.cwd(), ".archlast-deploy");
+        // Don't rewrite imports from _generated/server since we now include that file
+        // Only rewrite schema/definition imports
+        let rewritten = code.replace(/from\s+["']@archlast\/server\/schema\/definition["']/g, 'from "@archlast/server/schema/definition"');
+        // Rewrite relative module imports to absolute paths within .archlast-deploy
+        // e.g., from '../modules/tasks/task.helper' -> from 'F:/path/.archlast-deploy/modules/tasks/task.helper'
+        rewritten = rewritten.replace(/from\s+["']\.\.\/((modules|src)\/[^"']+)["']/g, (match, modulePath) => {
+            const absolutePath = join(deployDir, modulePath).replace(/\\/g, "/");
+            return `from "${absolutePath}"`;
+        });
+        return rewritten;
+    }
+    hasFileChanges(currentState, incomingFiles) {
+        if (!currentState)
+            return true;
+        // Create maps for comparison
+        const currentMap = new Map(currentState.files.map((f) => [f.filePath, f.code.trim()]));
+        const incomingMap = new Map(incomingFiles.map((f) => [f.filePath, f.code.trim()]));
+        // Check if file count changed
+        if (currentMap.size !== incomingMap.size)
+            return true;
+        // Check if any file content changed
+        for (const [path, code] of incomingMap) {
+            const currentCode = currentMap.get(path);
+            if (!currentCode || currentCode !== code) {
+                return true;
+            }
+        }
+        return false;
+    }
+    hashString(str) {
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash = hash & hash;
+        }
+        return Math.abs(hash).toString(36);
+    }
+    /**
+     * Recursively clean up empty directories
+     */
+    async cleanEmptyDirs(dirPath) {
+        try {
+            const { readdir } = await import("fs/promises");
+            const { join } = await import("path");
+            const entries = await readdir(dirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = join(dirPath, entry.name);
+                if (entry.isDirectory()) {
+                    await this.cleanEmptyDirs(fullPath);
+                    // Check if directory is now empty
+                    const remainingEntries = await readdir(fullPath);
+                    if (remainingEntries.length === 0) {
+                        const { rmdir } = await import("fs/promises");
+                        await rmdir(fullPath);
+                        logger_js_1.logger.log({
+                            timestamp: Date.now(),
+                            level: "info",
+                            kind: "deployment",
+                            message: `Removed empty directory: ${fullPath}`,
+                        });
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Ignore errors during cleanup
+            logger_js_1.logger.log({
+                timestamp: Date.now(),
+                level: "warn",
+                kind: "deployment",
+                message: "Failed to clean empty directories",
+                context: { error },
+            });
+        }
+    }
+    getFunction(filePath, name) {
+        return this.uploadedFunctions.get(`${filePath}:${name}`);
+    }
+    getSchema() {
+        return this.uploadedSchema;
+    }
+    listFunctions() {
+        return Array.from(this.uploadedFunctions.values()).map((f) => ({
+            // IMPORTANT: For the dashboard registry, return the fully-qualified runtime name
+            // (e.g. "tasks.list") so the UI can call it over WS without guessing module prefixes.
+            name: f.fullName,
+            fullName: f.fullName,
+            type: f.type,
+            filePath: f.filePath,
+            // Best-effort: attach the Zod args object (when present) so the dashboard can scaffold JSON args.
+            // This is derived from the exported FunctionDefinition object loaded during deploy.
+            args: f.args,
+        }));
+    }
+    /**
+     * List all registered HTTP routes and webhooks with detailed metadata
+     */
+    listHttpRoutes() {
+        return Array.from(this.uploadedHttpRoutes.entries()).map(([key, route]) => {
+            const [moduleName, exportName] = key.split(":");
+            return {
+                path: route.path,
+                method: route.type === "webhook" ? (route.method ?? "POST") : route.method,
+                type: route.type,
+                auth: route.auth,
+                exportName,
+                moduleName,
+                permissions: route.type === "http" ? (route.permissions ?? undefined) : undefined,
+            };
+        });
+    }
+    /**
+     * List all registered RPC procedures with detailed metadata
+     */
+    listRpcRoutes() {
+        return Array.from(this.uploadedRpcRoutes.entries()).map(([key, route]) => {
+            const [moduleName, exportName] = key.split(":");
+            return {
+                name: exportName,
+                namespace: moduleName,
+                fullName: `${moduleName}.${exportName}`,
+                procedureType: route.procedureType,
+                auth: route.auth,
+                exportName,
+                moduleName,
+                permissions: route.permissions,
+            };
+        });
+    }
+    // --- New Deployment History Methods ---
+    async listDeployments() {
+        return this.persistence.listHistory();
+    }
+    async getDeployment(id) {
+        return this.persistence.getHistory(id);
+    }
+    /**
+     * Get manifest of current deployment (file paths and hashes)
+     */
+    getManifest() {
+        const currentState = this.persistence.loadSync();
+        if (!currentState) {
+            return {};
+        }
+        const manifest = {};
+        for (const file of currentState.files) {
+            manifest[file.filePath] = this.hashString(file.code.trim());
+        }
+        return manifest;
+    }
+    async getDeploymentDiff(id, baseId) {
+        const target = await this.persistence.getHistory(id);
+        if (!target)
+            return null;
+        let base = null;
+        if (baseId) {
+            base = await this.persistence.getHistory(baseId);
+        }
+        else {
+            // If no base specified, try to find the one immediately before 'id'
+            // This is naive and assumes listHistory is ordered.
+            const history = await this.persistence.listHistory();
+            const idx = history.findIndex((d) => d.id === id);
+            if (idx !== -1 && idx < history.length - 1) {
+                base = await this.persistence.getHistory(history[idx + 1].id);
+            }
+        }
+        if (!base) {
+            // First deployment: everything is added
+            return target.files.map((f) => ({
+                filePath: f.filePath,
+                status: "added",
+                chunks: [], // Lightweight diff
+            }));
+        }
+        const baseMap = new Map(base.files.map((f) => [f.filePath, f.code]));
+        const targetMap = new Map(target.files.map((f) => [f.filePath, f.code]));
+        const diffs = [];
+        // Check for added/changed
+        for (const [path, code] of targetMap) {
+            if (!baseMap.has(path)) {
+                diffs.push({ filePath: path, status: "added" });
+            }
+            else if (baseMap.get(path) !== code) {
+                diffs.push({ filePath: path, status: "modified" });
+            }
+        }
+        // Check for removed
+        for (const [path] of baseMap) {
+            if (!targetMap.has(path)) {
+                diffs.push({ filePath: path, status: "removed" });
+            }
+        }
+        return diffs;
+    }
+    /**
+     * Handle delta deployment - only process changed files
+     * @returns Deployment result with deployment type indicator
+     */
+    async handleDeltaDeploy(payload) {
+        // Acquire deployment lock
+        if (!(await this.acquireLock())) {
+            return {
+                success: false,
+                message: "Deployment in progress, please wait",
+                functions: 0,
+                schema: false,
+                deploymentType: "delta",
+            };
+        }
+        try {
+            // Validate payload
+            if (!payload || !payload.changes) {
+                throw new Error("Invalid delta payload: 'changes' object is missing");
+            }
+            const { added, modified, removed } = payload.changes;
+            const hasChanges = added.length > 0 || modified.length > 0 || removed.length > 0;
+            if (!hasChanges) {
+                return {
+                    success: true,
+                    message: "No changes to apply",
+                    functions: 0,
+                    schema: false,
+                    deploymentType: "delta",
+                };
+            }
+            const currentState = await this.persistence.load();
+            if (!currentState) {
+                // No existing state - fall back to full deployment
+                logger_js_1.logger.log({
+                    timestamp: Date.now(),
+                    level: "info",
+                    kind: "deployment",
+                    message: "No existing state, falling back to full deployment",
+                });
+                return this.fallbackToFullDeploy(payload);
+            }
+            // Verify integrity if manifest hash provided
+            if (payload.manifestHash) {
+                const expectedHash = payload.manifestHash;
+                const computedHash = this.computeExpectedHash(currentState, payload.changes);
+                if (expectedHash !== computedHash) {
+                    logger_js_1.logger.log({
+                        timestamp: Date.now(),
+                        level: "warn",
+                        kind: "deployment",
+                        message: "Manifest hash mismatch, falling back to full deployment",
+                        context: { expected: expectedHash, computed: computedHash },
+                    });
+                    return this.fallbackToFullDeploy(payload);
+                }
+            }
+            const { join } = await import("path");
+            const fs = await import("fs/promises");
+            const deployDir = join(process.cwd(), ".archlast-deploy");
+            // Track affected modules for reloading
+            const affectedModules = new Set();
+            const schemaChanged = this.checkSchemaChanged(payload.changes);
+            const diChanged = this.checkDIChanged(payload.changes);
+            const trpcRouterChanged = this.checkTrpcRouterChanged(payload.changes);
+            // Apply removals first
+            for (const filePath of removed) {
+                const fullPath = join(deployDir, filePath);
+                try {
+                    await fs.rm(fullPath, { force: true });
+                    affectedModules.add(this.getModuleName(filePath));
+                    // Unregister functions from this file
+                    await this.unregisterFunctionsFromFile(filePath);
+                    logger_js_1.logger.log({
+                        timestamp: Date.now(),
+                        level: "info",
+                        kind: "deployment",
+                        message: `[Delta] Removed file: ${filePath}`,
+                    });
+                }
+                catch (err) {
+                    logger_js_1.logger.log({
+                        timestamp: Date.now(),
+                        level: "warn",
+                        kind: "deployment",
+                        message: `[Delta] Failed to remove file: ${filePath}`,
+                        context: { err },
+                    });
+                }
+            }
+            // Apply additions and modifications
+            const allChanges = [...added, ...modified];
+            for (const file of allChanges) {
+                const filePath = join(deployDir, file.filePath);
+                const fileDir = join(filePath, "..");
+                await fs.mkdir(fileDir, { recursive: true });
+                // Rewrite imports for files in src/
+                const code = file.filePath.startsWith("src/")
+                    ? await this.rewriteImports(file.code)
+                    : file.code;
+                await Bun.write(filePath, code);
+                affectedModules.add(this.getModuleName(file.filePath));
+                logger_js_1.logger.log({
+                    timestamp: Date.now(),
+                    level: "info",
+                    kind: "deployment",
+                    message: `[Delta] ${added.includes(file) ? "Added" : "Modified"}: ${file.filePath}`,
+                });
+            }
+            // Update state in memory
+            const newState = this.applyDeltaToState(currentState, payload.changes);
+            // Incremental reload of affected modules
+            let functionsRegistered = 0;
+            // Reload DI if changed
+            if (diChanged) {
+                const diFile = newState.files.find((f) => f.filePath.endsWith("_generated/di.ts") ||
+                    f.filePath.endsWith("_generated/di.js"));
+                if (diFile) {
+                    try {
+                        const diPath = join(deployDir, diFile.filePath);
+                        const diMod = await import(diPath + `?t=${Date.now()}`);
+                        if (diMod && typeof diMod.registerProviders === "function") {
+                            const { globalContainer } = await import("../di/container.js");
+                            diMod.registerProviders(globalContainer);
+                            logger_js_1.logger.log({
+                                timestamp: Date.now(),
+                                level: "info",
+                                kind: "deployment",
+                                message: "[Delta] Re-registered DI providers",
+                            });
+                        }
+                    }
+                    catch (err) {
+                        logger_js_1.logger.log({
+                            timestamp: Date.now(),
+                            level: "error",
+                            kind: "deployment",
+                            message: "[Delta] Failed to re-register DI providers",
+                            context: { err },
+                        });
+                    }
+                }
+            }
+            // Reload tRPC router if changed
+            if (trpcRouterChanged) {
+                const trpcRouterFile = newState.files.find((f) => f.filePath.endsWith("_generated/trpc-router.ts") ||
+                    f.filePath.endsWith("_generated/trpc-router.js"));
+                if (trpcRouterFile) {
+                    try {
+                        const routerPath = join(deployDir, trpcRouterFile.filePath);
+                        const routerMod = await import(routerPath + `?t=${Date.now()}`);
+                        if (routerMod && routerMod.appRouter) {
+                            this.rpcRouter = routerMod.appRouter;
+                            logger_js_1.logger.log({
+                                timestamp: Date.now(),
+                                level: "info",
+                                kind: "deployment",
+                                message: "[Delta] Reloaded static tRPC appRouter from trpc-router.ts",
+                            });
+                        }
+                    }
+                    catch (err) {
+                        logger_js_1.logger.log({
+                            timestamp: Date.now(),
+                            level: "error",
+                            kind: "deployment",
+                            message: "[Delta] Failed to reload tRPC router",
+                            context: { err },
+                        });
+                    }
+                }
+            }
+            // Reload schema if changed
+            if (schemaChanged) {
+                const schemaFile = newState.files.find((f) => f.filePath.endsWith("schema.ts"));
+                if (schemaFile) {
+                    try {
+                        const schemaPath = join(deployDir, schemaFile.filePath);
+                        const mod = await import(schemaPath + `?t=${Date.now()}`);
+                        if (mod.default && mod.default.tables) {
+                            const mergedSchema = {
+                                ...mod.default,
+                                tables: {
+                                    ...(mod.default.tables ?? {}),
+                                    ...schema_js_1.authSchema.tables,
+                                },
+                            };
+                            this.uploadedSchema = mergedSchema;
+                            await this.db.applySchema(mergedSchema);
+                            logger_js_1.logger.log({
+                                timestamp: Date.now(),
+                                level: "info",
+                                kind: "deployment",
+                                message: "[Delta] Schema reloaded",
+                            });
+                        }
+                    }
+                    catch (err) {
+                        logger_js_1.logger.log({
+                            timestamp: Date.now(),
+                            level: "error",
+                            kind: "deployment",
+                            message: "[Delta] Failed to reload schema",
+                            context: { err },
+                        });
+                    }
+                }
+            }
+            // Reload affected modules
+            for (const moduleName of affectedModules) {
+                const files = newState.files.filter((f) => this.getModuleName(f.filePath) === moduleName);
+                for (const file of files) {
+                    if (file.filePath.endsWith("schema.ts") ||
+                        file.filePath.includes("_generated/")) {
+                        continue; // Already handled
+                    }
+                    const fullPath = join(deployDir, file.filePath);
+                    const hasFunctions = /export\s+(?:const|let)\s+\w+\s*=\s*(?:query|mutation|action|http\.(?:get|post|put|patch|delete)|webhook|rpc\.(?:query|mutation))\s*\(/g.test(file.code);
+                    if (hasFunctions) {
+                        try {
+                            const mod = await import(fullPath + `?t=${Date.now()}`);
+                            // Unregister old functions from this module
+                            await this.unregisterFunctionsFromFile(file.filePath);
+                            // Register new functions
+                            for (const [key, value] of Object.entries(mod)) {
+                                if ((0, definition_js_1.isHttpDefinition)(value) || (0, definition_js_1.isWebhookDefinition)(value)) {
+                                    const routeKey = `${moduleName}:${key}`;
+                                    this.uploadedHttpRoutes.set(routeKey, value);
+                                    if (this.httpRouter) {
+                                        this.httpRouter.register(value);
+                                    }
+                                    continue;
+                                }
+                                if ((0, definition_js_1.isRpcDefinition)(value)) {
+                                    const routeKey = `${moduleName}:${key}`;
+                                    this.uploadedRpcRoutes.set(routeKey, value);
+                                    if (this.rpcRouter) {
+                                        this.rpcRouter.register(moduleName, key, value);
+                                    }
+                                    continue;
+                                }
+                                if (value &&
+                                    typeof value === "object" &&
+                                    "type" in value &&
+                                    "handler" in value) {
+                                    const fnName = `${moduleName}.${key}`;
+                                    this.engine.registerFunction(fnName, value);
+                                    this.uploadedFunctions.set(`${moduleName}:${key}`, {
+                                        name: key,
+                                        type: value.type,
+                                        filePath: fullPath,
+                                        fullName: fnName,
+                                        args: value.args,
+                                        timestamp: payload.timestamp,
+                                    });
+                                    functionsRegistered++;
+                                }
+                            }
+                        }
+                        catch (err) {
+                            logger_js_1.logger.log({
+                                timestamp: Date.now(),
+                                level: "error",
+                                kind: "deployment",
+                                message: `[Delta] Failed to reload module: ${moduleName}`,
+                                context: { err },
+                            });
+                        }
+                    }
+                }
+            }
+            // Clean up empty directories
+            await this.cleanEmptyDirs(deployDir);
+            // Save updated state
+            await this.persistence.save(newState);
+            await this.persistence.saveHistory({ ...newState, lastDeployment: payload.timestamp }, {
+                timestamp: payload.timestamp,
+                functionCount: functionsRegistered,
+                schemaChanged,
+                hash: this.hashString(JSON.stringify(newState)),
+            });
+            // Broadcast notification
+            try {
+                const { broadcastNotification } = await import("../functions/built-in/system-notifications.js");
+                broadcastNotification({
+                    title: "Delta Deployment Complete",
+                    description: `${functionsRegistered} function(s) updated${schemaChanged ? ", schema updated" : ""}`,
+                    type: "success",
+                    data: {
+                        functionCount: functionsRegistered,
+                        schemaChanged,
+                        added: added.length,
+                        modified: modified.length,
+                        removed: removed.length,
+                        timestamp: payload.timestamp,
+                    },
+                });
+            }
+            catch (err) {
+                // Ignore notification errors
+            }
+            // Emit deployment complete event for reactive CLI
+            (0, deployment_events_controller_js_1.emitDeploymentComplete)("delta");
+            setTimeout(() => {
+                logger_js_1.logger.log({
+                    timestamp: Date.now(),
+                    level: "info",
+                    kind: "deployment",
+                    message: "Restarting server after delta deployment...",
+                });
+                process.exit(0);
+            }, 200);
+            return {
+                success: true,
+                message: `Delta deployment successful: ${added.length} added, ${modified.length} modified, ${removed.length} removed`,
+                functions: functionsRegistered,
+                schema: schemaChanged,
+                deploymentType: "delta",
+            };
+        }
+        catch (error) {
+            logger_js_1.logger.log({
+                timestamp: Date.now(),
+                level: "error",
+                kind: "deployment",
+                message: "Delta deployment failed",
+                context: { error },
+            });
+            return {
+                success: false,
+                message: error instanceof Error ? error.message : "Unknown error",
+                functions: 0,
+                schema: false,
+                deploymentType: "delta",
+            };
+        }
+        finally {
+            // Always release the lock
+            this.releaseLock();
+        }
+    }
+    /**
+     * Apply delta changes to deployment state
+     */
+    applyDeltaToState(currentState, changes) {
+        const fileMap = new Map(currentState.files.map((f) => [f.filePath, f]));
+        // Remove files
+        for (const filePath of changes.removed) {
+            fileMap.delete(filePath);
+        }
+        // Add or update files
+        const allChanges = [...changes.added, ...changes.modified];
+        for (const file of allChanges) {
+            fileMap.set(file.filePath, { filePath: file.filePath, code: file.code });
+        }
+        return {
+            files: Array.from(fileMap.values()),
+            lastDeployment: Date.now(),
+        };
+    }
+    /**
+     * Check if schema file changed
+     */
+    checkSchemaChanged(changes) {
+        const allFiles = [...changes.added, ...changes.modified];
+        return allFiles.some((f) => f.filePath.endsWith("schema.ts"));
+    }
+    /**
+     * Check if DI file changed
+     */
+    checkDIChanged(changes) {
+        const allFiles = [...changes.added, ...changes.modified];
+        return allFiles.some((f) => f.filePath.endsWith("_generated/di.ts") || f.filePath.endsWith("_generated/di.js"));
+    }
+    /**
+     * Check if tRPC router file changed
+     */
+    checkTrpcRouterChanged(changes) {
+        const allFiles = [...changes.added, ...changes.modified];
+        return allFiles.some((f) => f.filePath.endsWith("_generated/trpc-router.ts") ||
+            f.filePath.endsWith("_generated/trpc-router.js"));
+    }
+    /**
+     * Get module name from file path
+     */
+    getModuleName(filePath) {
+        const parts = filePath.split(/[\\/]/);
+        const fileName = parts[parts.length - 1];
+        return fileName.replace(/\.(ts|js)$/, "");
+    }
+    /**
+     * Unregister functions from a specific file
+     */
+    async unregisterFunctionsFromFile(filePath) {
+        const moduleName = this.getModuleName(filePath);
+        // Find and remove functions registered from this file
+        for (const [key, value] of this.uploadedFunctions.entries()) {
+            if (value.filePath.endsWith(filePath)) {
+                this.engine.unregisterFunction(value.fullName);
+                this.uploadedFunctions.delete(key);
+                logger_js_1.logger.log({
+                    timestamp: Date.now(),
+                    level: "info",
+                    kind: "deployment",
+                    message: `[Delta] Unregistered function: ${value.fullName}`,
+                });
+            }
+        }
+        // Remove HTTP routes from this module
+        const routesToRemove = [];
+        for (const [key] of this.uploadedHttpRoutes.entries()) {
+            if (key.startsWith(`${moduleName}:`)) {
+                routesToRemove.push(key);
+            }
+        }
+        for (const key of routesToRemove) {
+            const value = this.uploadedHttpRoutes.get(key);
+            if (value) {
+                // Remove from our tracking
+                this.uploadedHttpRoutes.delete(key);
+                // Note: HttpRouter doesn't support unregister, so we need to clear and reload all routes
+                // This will be handled by the caller via a full route reload if needed
+                logger_js_1.logger.log({
+                    timestamp: Date.now(),
+                    level: "info",
+                    kind: "deployment",
+                    message: `[Delta] Removed route from tracking: ${value.path}`,
+                });
+            }
+        }
+        // Remove RPC routes from this module
+        const rpcRoutesToRemove = [];
+        for (const [key] of this.uploadedRpcRoutes.entries()) {
+            if (key.startsWith(`${moduleName}:`)) {
+                rpcRoutesToRemove.push(key);
+            }
+        }
+        for (const key of rpcRoutesToRemove) {
+            const value = this.uploadedRpcRoutes.get(key);
+            if (value && this.rpcRouter) {
+                this.rpcRouter.unregister(moduleName, key.split(":")[1]);
+                this.uploadedRpcRoutes.delete(key);
+                logger_js_1.logger.log({
+                    timestamp: Date.now(),
+                    level: "info",
+                    kind: "deployment",
+                    message: `[Delta] Unregistered RPC procedure: ${moduleName}.${key.split(":")[1]}`,
+                });
+            }
+        }
+    }
+    /**
+     * Compute expected hash after applying delta
+     */
+    computeExpectedHash(currentState, changes) {
+        const newState = this.applyDeltaToState(currentState, changes);
+        const filesHashStr = newState.files
+            .sort((a, b) => a.filePath.localeCompare(b.filePath))
+            .map((f) => `${f.filePath}:${this.hashString(f.code.trim())}`)
+            .join(";");
+        return this.hashString(filesHashStr);
+    }
+    /**
+     * Fall back to full deployment when delta is not possible
+     */
+    async fallbackToFullDeploy(deltaPayload) {
+        // Reconstruct full payload from current state + delta
+        const currentState = await this.persistence.load();
+        const fullPayload = {
+            timestamp: deltaPayload.timestamp,
+            files: [],
+        };
+        if (currentState) {
+            // Start with existing files
+            fullPayload.files = [...currentState.files];
+        }
+        // Apply delta to reconstruct full state
+        const fileMap = new Map(fullPayload.files.map((f) => [f.filePath, f]));
+        // Remove deleted files
+        for (const filePath of deltaPayload.changes.removed) {
+            fileMap.delete(filePath);
+        }
+        // Add/update files
+        for (const file of [...deltaPayload.changes.added, ...deltaPayload.changes.modified]) {
+            fileMap.set(file.filePath, { filePath: file.filePath, code: file.code });
+        }
+        fullPayload.files = Array.from(fileMap.values());
+        // Delegate to existing full deploy handler
+        const result = await this.handleDeploy(fullPayload);
+        return {
+            ...result,
+            deploymentType: "full",
+        };
+    }
+    /**
+     * Get schema source code from current deployment
+     */
+    getSchemaSource() {
+        const currentState = this.persistence.loadSync();
+        if (!currentState)
+            return null;
+        const schemaFile = currentState.files.find((f) => f.filePath === "src/schema.ts");
+        if (!schemaFile)
+            return null;
+        return {
+            source: schemaFile.code,
+            filePath: schemaFile.filePath,
+        };
+    }
+    /**
+     * Update schema with validation and hot reload
+     */
+    async updateSchema(source) {
+        try {
+            const currentState = this.persistence.loadSync();
+            if (!currentState) {
+                return {
+                    success: false,
+                    errors: [{ line: 0, column: 0, message: "No deployment found" }],
+                };
+            }
+            const schemaFile = currentState.files.find((f) => f.filePath === "src/schema.ts");
+            if (!schemaFile) {
+                return {
+                    success: false,
+                    errors: [
+                        { line: 0, column: 0, message: "Schema file not found in deployment" },
+                    ],
+                };
+            }
+            const { join } = await import("path");
+            const fs = await import("fs/promises");
+            const deployDir = join(process.cwd(), ".archlast-deploy");
+            const schemaPath = join(deployDir, "src/schema.ts");
+            const rewrittenSource = await this.rewriteImports(source);
+            await Bun.write(schemaPath, rewrittenSource);
+            const errors = [];
+            try {
+                const mod = await import(schemaPath + `?t=${Date.now()}`);
+                if (!mod.default || !mod.default.tables) {
+                    errors.push({
+                        line: 0,
+                        column: 0,
+                        message: "Schema must export default with tables",
+                    });
+                }
+                else {
+                    const tables = mod.default.tables;
+                    for (const [tableName, tableDef] of Object.entries(tables)) {
+                        if (!tableDef || typeof tableDef !== "object") {
+                            errors.push({
+                                line: 0,
+                                column: 0,
+                                message: `Table "${tableName}" is not a valid table definition`,
+                            });
+                            continue;
+                        }
+                        if (!tableDef.schema ||
+                            typeof tableDef.schema !== "object") {
+                            errors.push({
+                                line: 0,
+                                column: 0,
+                                message: `Table "${tableName}" missing schema definition`,
+                            });
+                        }
+                    }
+                }
+            }
+            catch (parseError) {
+                const errorStr = String(parseError);
+                const lineMatch = errorStr.match(/:(\d+):(\d+)/);
+                if (lineMatch) {
+                    errors.push({
+                        line: parseInt(lineMatch[1], 10),
+                        column: parseInt(lineMatch[2], 10),
+                        message: errorStr.split("\n").pop() || "Parse error",
+                    });
+                }
+                else {
+                    errors.push({ line: 0, column: 0, message: errorStr });
+                }
+            }
+            if (errors.length > 0) {
+                return { success: false, errors };
+            }
+            const newState = {
+                ...currentState,
+                files: currentState.files.map((f) => f.filePath === "src/schema.ts" ? { ...f, code: source } : f),
+            };
+            await this.persistence.save(newState);
+            const mod = await import(schemaPath + `?t=${Date.now()}`);
+            if (mod.default && mod.default.tables) {
+                const mergedSchema = {
+                    ...mod.default,
+                    tables: {
+                        ...(mod.default.tables ?? {}),
+                        ...schema_js_1.authSchema.tables,
+                    },
+                };
+                this.uploadedSchema = mergedSchema;
+                await this.db.applySchema(mergedSchema);
+            }
+            return { success: true };
+        }
+        catch (error) {
+            return {
+                success: false,
+                errors: [
+                    {
+                        line: 0,
+                        column: 0,
+                        message: error instanceof Error ? error.message : String(error),
+                    },
+                ],
+            };
+        }
+    }
+    /**
+     * Get deployment files for CLI pull
+     */
+    getDeploymentFiles(filePaths) {
+        const currentState = this.persistence.loadSync();
+        if (!currentState)
+            return [];
+        const filesToReturn = filePaths
+            ? currentState.files.filter((f) => filePaths.includes(f.filePath))
+            : currentState.files;
+        return filesToReturn.map((f) => ({
+            filePath: f.filePath,
+            code: f.code,
+        }));
+    }
+    /**
+     * Get pull metadata for smart diff detection
+     * @param localHashes Optional map of local file hashes from CLI
+     * @returns Pull metadata with change information
+     */
+    getPullMetadata(localHashes) {
+        return this.persistence.computePullMetadata(localHashes);
+    }
+    /**
+     * Extract function and schema metadata from deployment files
+     * @param files Deployment files
+     * @param timestamp Deployment timestamp
+     * @returns Object containing functions and schema metadata
+     */
+    extractDeploymentMetadata(files, timestamp) {
+        const functions = [];
+        let schema = null;
+        for (const file of files) {
+            // Extract functions from source files
+            if (file.filePath.startsWith("src/") &&
+                (file.code.includes("query(") ||
+                    file.code.includes("mutation(") ||
+                    file.code.includes("action("))) {
+                const fileFunctions = (0, function_extractor_js_1.extractFunctionsFromSource)(file.code, file.filePath, timestamp);
+                functions.push(...fileFunctions);
+            }
+            // Extract schema metadata
+            if (file.filePath.endsWith("schema.ts")) {
+                schema = (0, function_extractor_js_1.extractSchemaMetadata)(file.code, file.filePath, timestamp);
+            }
+        }
+        return { functions, schema };
+    }
+}
+exports.DeploymentHandler = DeploymentHandler;
+//# sourceMappingURL=handler.js.map