firebase-tools 15.16.0 → 15.18.0

package/lib/api.js

@@ -66,7 +66,7 @@ const functionsV2Origin = () => utils.envOverride("FIREBASE_FUNCTIONS_V2_URL", "
 exports.functionsV2Origin = functionsV2Origin;
 const runOrigin = () => utils.envOverride("CLOUD_RUN_URL", "https://run.googleapis.com");
 exports.runOrigin = runOrigin;
-const functionsDefaultRegion = () => utils.envOverride("FIREBASE_FUNCTIONS_DEFAULT_REGION", "us-central1");
+const functionsDefaultRegion = () => utils.envOverride("FIREBASE_FUNCTIONS_DEFAULT_REGION", "REGION_TBD");
 exports.functionsDefaultRegion = functionsDefaultRegion;
 const cloudbuildOrigin = () => utils.envOverride("FIREBASE_CLOUDBUILD_URL", "https://cloudbuild.googleapis.com");
 exports.cloudbuildOrigin = cloudbuildOrigin;

package/lib/apphosting/localbuilds.js

@@ -1,10 +1,121 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runUniversalMaker = runUniversalMaker;
 exports.localBuild = localBuild;
-const build_1 = require("@apphosting/build");
-const secrets_1 = require("./secrets");
+const childProcess = require("child_process");
+const fs = require("fs-extra");
+const path = require("path");
+const index_1 = require("./secrets/index");
 const prompt_1 = require("../prompt");
 const error_1 = require("../error");
+const logger_1 = require("../logger");
+const utils_1 = require("../utils");
+const universalMakerDownload_1 = require("./universalMakerDownload");
+async function runUniversalMaker(projectRoot, framework) {
+    const universalMakerBinary = await (0, universalMakerDownload_1.getOrDownloadUniversalMaker)();
+    executeUniversalMakerBinary(universalMakerBinary, projectRoot);
+    return processUniversalMakerOutput(projectRoot, framework);
+}
+function executeUniversalMakerBinary(universalMakerBinary, projectRoot) {
+    try {
+        const bundleOutput = path.join(projectRoot, "bundle_output");
+        fs.removeSync(bundleOutput);
+        fs.ensureDirSync(bundleOutput);
+        const res = childProcess.spawnSync(universalMakerBinary, ["-application_dir", projectRoot, "-output_dir", projectRoot, "-output_format", "json"], {
+            env: {
+                ...process.env,
+                X_GOOGLE_TARGET_PLATFORM: "fah",
+                FIREBASE_OUTPUT_BUNDLE_DIR: bundleOutput,
+            },
+            stdio: "pipe",
+        });
+        if (res.stdout) {
+            logger_1.logger.debug("[Universal Maker stdout]:\n" + res.stdout.toString());
+        }
+        if (res.stderr) {
+            logger_1.logger.debug("[Universal Maker stderr]:\n" + res.stderr.toString());
+        }
+        if (res.error) {
+            throw res.error;
+        }
+        if (res.status !== 0) {
+            throw new error_1.FirebaseError(`Universal Maker failed with exit code ${res.status ?? "unknown"}.`);
+        }
+    }
+    catch (e) {
+        if (e && typeof e === "object" && "code" in e && e.code === "EACCES") {
+            throw new error_1.FirebaseError(`Failed to execute the Universal Maker binary at ${universalMakerBinary} due to permission constraints. Please assure you have set execution permissions (e.g., chmod +x) on the file.`);
+        }
+        throw e;
+    }
+}
+function parseBundleYaml(projectRoot, defaultRunCommand) {
+    const bundleYamlPath = path.join(projectRoot, ".apphosting", "bundle.yaml");
+    if (!fs.existsSync(bundleYamlPath)) {
+        throw new error_1.FirebaseError("Failed to resolve build artifacts. Ensure Universal Maker produced a valid bundle.yaml with outputFiles.");
+    }
+    const bundleRaw = fs.readFileSync(bundleYamlPath, "utf-8");
+    const bundleData = (0, utils_1.wrappedSafeLoad)(bundleRaw);
+    const runCommand = bundleData?.runConfig?.runCommand ?? defaultRunCommand;
+    const outputFiles = bundleData?.outputFiles?.serverApp?.include;
+    if (!outputFiles) {
+        throw new error_1.FirebaseError("Failed to resolve build artifacts. Ensure Universal Maker produced a valid bundle.yaml with outputFiles.");
+    }
+    return { runCommand, outputFiles };
+}
+function processUniversalMakerOutput(projectRoot, framework) {
+    const outputFilePath = path.join(projectRoot, "build_output.json");
+    if (!fs.existsSync(outputFilePath)) {
+        throw new error_1.FirebaseError(`Universal Maker did not produce the expected output file at ${outputFilePath}`);
+    }
+    const outputRaw = fs.readFileSync(outputFilePath, "utf-8");
+    fs.unlinkSync(outputFilePath);
+    const bundleOutput = path.join(projectRoot, "bundle_output");
+    const targetAppHosting = path.join(projectRoot, ".apphosting");
+    if (fs.existsSync(bundleOutput)) {
+        fs.ensureDirSync(targetAppHosting);
+        const files = fs.readdirSync(bundleOutput);
+        for (const file of files) {
+            const dest = path.join(targetAppHosting, file);
+            if (fs.existsSync(dest)) {
+                fs.removeSync(dest);
+            }
+            fs.moveSync(path.join(bundleOutput, file), dest);
+        }
+        fs.removeSync(bundleOutput);
+    }
+    let umOutput;
+    try {
+        umOutput = JSON.parse(outputRaw);
+    }
+    catch (e) {
+        throw new error_1.FirebaseError(`Failed to parse build_output.json: ${(0, error_1.getErrMsg)(e)}`);
+    }
+    const defaultRunCommand = `${umOutput.command} ${umOutput.args.join(" ")}`;
+    const { runCommand: finalRunCommand, outputFiles: finalOutputFiles } = parseBundleYaml(projectRoot, defaultRunCommand);
+    return {
+        metadata: {
+            language: umOutput.language,
+            runtime: umOutput.runtime,
+            framework: framework || "nextjs",
+        },
+        runConfig: {
+            runCommand: finalRunCommand,
+            environmentVariables: Object.entries(umOutput.envVars || {})
+                .filter(([k]) => k !== "FIREBASE_OUTPUT_BUNDLE_DIR")
+                .map(([k, v]) => ({
+                variable: k,
+                value: String(v),
+                availability: ["RUNTIME"],
+            })),
+        },
+        outputFiles: {
+            serverApp: {
+                include: finalOutputFiles,
+            },
+        },
+    };
+}
 async function localBuild(projectId, projectRoot, framework, env = {}, options) {
     const hasBuildAvailableSecrets = Object.values(env).some((v) => v.secret && (!v.availability || v.availability.includes("BUILD")));
     if (hasBuildAvailableSecrets && !options?.allowLocalBuildSecrets) {
@@ -25,7 +136,7 @@ async function localBuild(projectId, projectRoot, framework, env = {}, options)
     }
     let apphostingBuildOutput;
     try {
-        apphostingBuildOutput = await (0, build_1.localBuild)(projectRoot, framework);
+        apphostingBuildOutput = await runUniversalMaker(projectRoot, framework);
     }
     finally {
         for (const key in process.env) {
@@ -41,7 +152,7 @@ async function localBuild(projectId, projectRoot, framework, env = {}, options)
     const discoveredEnv = apphostingBuildOutput.runConfig.environmentVariables?.map(({ variable, value, availability }) => ({
         variable,
         value,
-        availability,
+        availability: availability,
     }));
     return {
         outputFiles: apphostingBuildOutput.outputFiles?.serverApp.include ?? [],
@@ -58,7 +169,7 @@ async function toProcessEnv(projectId, env) {
             return null;
         }
         if (value.secret) {
-            const resolvedValue = await (0, secrets_1.loadSecret)(projectId, value.secret);
+            const resolvedValue = await (0, index_1.loadSecret)(projectId, value.secret);
             return [key, resolvedValue];
         }
         else {

package/lib/apphosting/universalMakerDownload.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOrDownloadUniversalMaker = getOrDownloadUniversalMaker;
+const fs = require("fs-extra");
+const os = require("os");
+const path = require("path");
+const error_1 = require("../error");
+const downloadUtils = require("../downloadUtils");
+const logger_1 = require("../logger");
+const universalMakerInfo = require("./universalMakerInfo.json");
+const CACHE_DIR = path.join(os.homedir(), ".cache", "firebase", "universal-maker");
+const UNIVERSAL_MAKER_UPDATE_DETAILS = universalMakerInfo;
+function getPlatformInfo() {
+    let platformKey = "";
+    if (process.platform === "darwin") {
+        if (process.arch === "arm64") {
+            platformKey = "darwin_arm64";
+        }
+        else {
+            throw new error_1.FirebaseError("macOS Intel (darwin_x64) is not currently supported for Universal Maker.");
+        }
+    }
+    else if (process.platform === "linux") {
+        if (process.arch === "x64") {
+            platformKey = "linux_x64";
+        }
+        else {
+            throw new error_1.FirebaseError("Linux ARM (linux_arm64) is not currently supported for Universal Maker.");
+        }
+    }
+    else if (process.platform === "win32") {
+        throw new error_1.FirebaseError("Windows (win32) is not currently supported for Universal Maker.");
+    }
+    else {
+        throw new error_1.FirebaseError(`Unsupported platform for Universal Maker: ${process.platform} ${process.arch}`);
+    }
+    const details = UNIVERSAL_MAKER_UPDATE_DETAILS[platformKey];
+    if (!details) {
+        throw new error_1.FirebaseError(`Could not find download details for platform: ${platformKey}`);
+    }
+    return details;
+}
+async function getOrDownloadUniversalMaker() {
+    const details = getPlatformInfo();
+    const downloadPath = path.join(CACHE_DIR, details.downloadPathRelativeToCacheDir);
+    const hasBinary = fs.existsSync(downloadPath);
+    if (hasBinary) {
+        logger_1.logger.debug(`[apphosting] Universal Maker binary found at cache: ${downloadPath}`);
+        try {
+            await downloadUtils.validateSize(downloadPath, details.expectedSize);
+            await downloadUtils.validateChecksum(downloadPath, details.expectedChecksumSHA256, "sha256");
+            return downloadPath;
+        }
+        catch (err) {
+            logger_1.logger.warn(`[apphosting] Cached Universal Maker binary failed verification: ${err.message}. Proceeding to redownload...`);
+        }
+    }
+    logger_1.logger.info("Downloading Universal Maker, a tool required to build your App Hosting application locally...");
+    fs.ensureDirSync(CACHE_DIR);
+    let tmpfile;
+    try {
+        tmpfile = await downloadUtils.downloadToTmp(details.remoteUrl);
+    }
+    catch (err) {
+        throw new error_1.FirebaseError(`Failed to download Universal Maker: ${err.message}`);
+    }
+    await downloadUtils.validateSize(tmpfile, details.expectedSize);
+    await downloadUtils.validateChecksum(tmpfile, details.expectedChecksumSHA256, "sha256");
+    fs.copySync(tmpfile, downloadPath);
+    fs.chmodSync(downloadPath, 0o755);
+    return downloadPath;
+}

package/lib/apphosting/universalMakerInfo.json

@@ -0,0 +1,16 @@
+{
+    "darwin_arm64": {
+        "version": "1.0.0",
+        "expectedSize": 16111618,
+        "expectedChecksumSHA256": "4b77d02a5f80f26d9bd1428f388c293c1fb264995d75b51c7d50fec7c87bcf58",
+        "remoteUrl": "https://artifactregistry.googleapis.com/download/v1/projects/serverless-runtimes-qa/locations/us-central1/repositories/universal-maker/files/darwin-arm64%3A1.0.0%3Auniversal_maker:download?alt=media",
+        "downloadPathRelativeToCacheDir": "universal-maker-darwin-arm64-1.0.0"
+    },
+    "linux_x64": {
+        "version": "1.0.0",
+        "expectedSize": 16856277,
+        "expectedChecksumSHA256": "dfc8357b8ce23ef1897e5590d4390f166e27734f241b770f721d68273118845c",
+        "remoteUrl": "https://artifactregistry.googleapis.com/download/v1/projects/serverless-runtimes-qa/locations/us-central1/repositories/universal-maker/files/x86-64%3A1.0.0%3Auniversal_maker:download?alt=media",
+        "downloadPathRelativeToCacheDir": "universal-maker-linux-x64-1.0.0"
+    }
+}

package/lib/archiveDirectory.js

@@ -43,7 +43,7 @@ async function zipDirectory(sourceDirectory, tempFile, options) {
     try {
         files = await fsAsync.readdirRecursive({
             path: sourceDirectory,
-            ignore: options.ignore,
+            ignoreStrings: options.ignore,
             ignoreSymlinks: true,
         });
     }

package/lib/deploy/apphosting/release.js

@@ -19,24 +19,39 @@ async function default_1(context, options) {
         return;
     }
     const projectId = (0, projectUtils_1.needProjectId)(options);
-    const rollouts = backendIds.map((backendId) => (0, rollout_1.orchestrateRollout)({
-        projectId,
-        backendId,
-        location: context.backendLocations[backendId],
-        buildInput: {
-            config: context.backendLocalBuilds[backendId]?.buildConfig,
-            source: {
+    const rollouts = backendIds.map((backendId) => {
+        const localBuild = context.backendLocalBuilds[backendId];
+        const userStorageUri = context.backendStorageUris[backendId];
+        const rootDirectory = context.backendConfigs[backendId].rootDir;
+        const source = localBuild
+            ? {
+                locallyBuilt: {
+                    userStorageUri,
+                    rootDirectory,
+                    runCommand: localBuild.buildConfig?.runCommand,
+                    env: localBuild.buildConfig?.env,
+                },
+            }
+            : {
                 archive: {
-                    userStorageUri: context.backendStorageUris[backendId],
-                    rootDirectory: context.backendConfigs[backendId].rootDir,
-                    locallyBuiltSource: !!context.backendLocalBuilds[backendId],
+                    userStorageUri,
+                    rootDirectory,
                 },
+            };
+        return (0, rollout_1.orchestrateRollout)({
+            projectId,
+            backendId,
+            location: context.backendLocations[backendId],
+            buildInput: {
+                config: localBuild?.buildConfig,
+                source,
             },
-        },
-    }));
+        });
+    });
     (0, utils_1.logLabeledBullet)("apphosting", `You may also track the rollout(s) at:\n\t${(0, api_1.consoleOrigin)()}/project/${projectId}/apphosting`);
     const rolloutsSpinner = ora(`Starting rollout(s) for backend(s) ${backendIds.join(", ")}; this may take a few minutes. It's safe to exit now.\n`).start();
     const results = await Promise.allSettled(rollouts);
+    rolloutsSpinner.stop();
     let failed = false;
     for (let i = 0; i < results.length; i++) {
         const res = results[i];
@@ -51,7 +66,6 @@ async function default_1(context, options) {
             (0, utils_1.logLabeledError)("apphosting", `${res.reason}`);
         }
     }
-    rolloutsSpinner.stop();
     if (failed) {
         throw new error_1.FirebaseError("One or more rollouts failed. Please review the errors above and try again.");
     }

package/lib/deploy/apphosting/util.js

@@ -16,8 +16,8 @@ async function createLocalBuildTarArchive(config, rootDir, targetSubDir) {
     const ignore = ["firebase-debug.log", "firebase-debug.*.log", ".git"];
     const rdrFiles = await fsAsync.readdirRecursive({
         path: targetDir,
-        ignore: ignore,
-        isGitIgnore: true,
+        ignoreStrings: ignore,
+        supportGitIgnore: true,
     });
     const allFiles = rdrFiles.map((rdrf) => path.relative(rootDir, rdrf.name));
     if (targetSubDir) {
@@ -60,13 +60,11 @@ async function createSourceDeployArchive(config, rootDir, targetSubDir) {
     const targetDir = targetSubDir ? path.join(rootDir, targetSubDir) : rootDir;
     const ignore = config.ignore || ["node_modules", ".git"];
     ignore.push("firebase-debug.log", "firebase-debug.*.log");
-    const gitIgnorePatterns = parseGitIgnorePatterns(targetDir);
-    ignore.push(...gitIgnorePatterns);
     try {
         const files = await fsAsync.readdirRecursive({
             path: targetDir,
-            ignore: ignore,
-            isGitIgnore: true,
+            ignoreStrings: ignore,
+            supportGitIgnore: true,
         });
         for (const file of files) {
             const name = path.relative(rootDir, file.name);
@@ -82,19 +80,6 @@ async function createSourceDeployArchive(config, rootDir, targetSubDir) {
     }
     return tmpFile;
 }
-function parseGitIgnorePatterns(projectRoot, gitIgnorePath = ".gitignore") {
-    const absoluteFilePath = path.resolve(projectRoot, gitIgnorePath);
-    if (!fs.existsSync(absoluteFilePath)) {
-        return [];
-    }
-    const lines = fs
-        .readFileSync(absoluteFilePath)
-        .toString()
-        .split("\n")
-        .map((line) => line.trim())
-        .filter((line) => !line.startsWith("#") && !(line === ""));
-    return lines;
-}
 async function pipeAsync(from, to) {
     from.pipe(to);
     await from.finalize();

package/lib/deploy/functions/backend.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.missingEndpoint = exports.hasEndpoint = exports.AllFunctionsPlatforms = exports.SCHEDULED_FUNCTION_LABEL = exports.MIN_CPU_FOR_CONCURRENCY = exports.DEFAULT_MEMORY = exports.DEFAULT_CONCURRENCY = exports.AllIngressSettings = exports.AllVpcEgressSettings = void 0;
+exports.missingEndpoint = exports.hasEndpoint = exports.AllFunctionsPlatforms = exports.SCHEDULED_FUNCTION_LABEL = exports.MIN_CPU_FOR_CONCURRENCY = exports.DEFAULT_TIMEOUT_SECONDS = exports.DEFAULT_MEMORY = exports.DEFAULT_CONCURRENCY = exports.AllIngressSettings = exports.AllVpcEgressSettings = void 0;
 exports.endpointTriggerType = endpointTriggerType;
 exports.isValidMemoryOption = isValidMemoryOption;
 exports.isValidEgressSetting = isValidEgressSetting;
@@ -116,6 +116,7 @@ function memoryToGen2Cpu(memory) {
 }
 exports.DEFAULT_CONCURRENCY = 80;
 exports.DEFAULT_MEMORY = 256;
+exports.DEFAULT_TIMEOUT_SECONDS = 60;
 exports.MIN_CPU_FOR_CONCURRENCY = 1;
 exports.SCHEDULED_FUNCTION_LABEL = Object.freeze({ deployment: "firebase-schedule" });
 function secretVersionName(s) {

package/lib/deploy/functions/prepare.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EVENTARC_SOURCE_ENV = void 0;
+exports.DEFAULT_FUNCTION_REGION = exports.EVENTARC_SOURCE_ENV = void 0;
 exports.prepare = prepare;
-exports.matchRegionsForExisting = matchRegionsForExisting;
-exports.resolveDefaultRegions = resolveDefaultRegions;
+exports.resolveDefaultRegionsForBuild = resolveDefaultRegionsForBuild;
 exports.inferDetailsFromExisting = inferDetailsFromExisting;
 exports.updateEndpointTargetedStatus = updateEndpointTargetedStatus;
 exports.inferBlockingDetails = inferBlockingDetails;
 exports.resolveCpuAndConcurrency = resolveCpuAndConcurrency;
+exports.resolveDefaultTimeout = resolveDefaultTimeout;
 exports.loadCodebases = loadCodebases;
 exports.warnIfNewGenkitFunctionIsMissingSecrets = warnIfNewGenkitFunctionIsMissingSecrets;
 exports.ensureAllRequiredAPIsEnabled = ensureAllRequiredAPIsEnabled;
@@ -23,6 +23,12 @@ const runtimes = require("./runtimes");
 const supported = require("./runtimes/supported");
 const validate = require("./validate");
 const ensure = require("./ensure");
+const events = require("../../functions/events/v1");
+const firestore_1 = require("./services/firestore");
+const storage_1 = require("./services/storage");
+const database_1 = require("./services/database");
+const ailogic_1 = require("./services/ailogic");
+const names_1 = require("../../dataconnect/names");
 const api_1 = require("../../api");
 const functionsDeployHelper_1 = require("./functionsDeployHelper");
 const utils_1 = require("../../utils");
@@ -43,6 +49,7 @@ const functional_1 = require("../../functional");
 const prepare_1 = require("../extensions/prepare");
 const prompt = require("../../prompt");
 exports.EVENTARC_SOURCE_ENV = "EVENTARC_CLOUD_EVENT_SOURCE";
+exports.DEFAULT_FUNCTION_REGION = "us-central1";
 async function prepare(context, options, payload) {
     const projectId = (0, projectUtils_1.needProjectId)(options);
     const projectNumber = await (0, projectUtils_1.needProjectNumber)(options);
@@ -71,6 +78,7 @@ async function prepare(context, options, payload) {
     }
     context.hasRuntimeConfig = Object.keys(runtimeConfig).some((k) => k !== "firebase");
     const wantBuilds = await loadCodebases(context.config, options, firebaseConfig, runtimeConfig, context.filters);
+    const existingBackend = await backend.existingBackend(context);
     if (Object.values(wantBuilds).some((b) => b.extensions)) {
         const extContext = {};
         const extPayload = {};
@@ -92,6 +100,10 @@ async function prepare(context, options, payload) {
         proto.convertIfPresent(userEnvOpt, localCfg, "configDir", (cd) => options.config.path(cd));
         const userEnvs = functionsEnv.loadUserEnvs(userEnvOpt);
         const envs = { ...userEnvs, ...firebaseEnvs };
+        const relevantEndpoints = backend
+            .allEndpoints(existingBackend)
+            .filter((e) => e.codebase === codebase || e.codebase === undefined);
+        await resolveDefaultRegionsForBuild(wantBuild, backend.of(...relevantEndpoints));
         const { backend: wantBackend, envs: resolvedEnvs } = await build.resolveBackend({
             build: wantBuild,
             firebaseConfig,
@@ -187,13 +199,6 @@ async function prepare(context, options, payload) {
         context.sources[codebase] = source;
     }
     payload.functions = {};
-    const existingBackend = await backend.existingBackend(context);
-    for (const [codebase, wantBackend] of Object.entries(wantBackends)) {
-        const relevantEndpoints = backend
-            .allEndpoints(existingBackend)
-            .filter((e) => e.codebase === codebase || e.codebase === undefined);
-        await resolveDefaultRegions(wantBackend, backend.of(...relevantEndpoints));
-    }
     const haveBackends = (0, functionsDeployHelper_1.groupEndpointsByCodebase)(wantBackends, backend.allEndpoints(existingBackend));
     for (const [codebase, wantBackend] of Object.entries(wantBackends)) {
         const haveBackend = haveBackends[codebase] || backend.empty();
@@ -203,6 +208,7 @@ async function prepare(context, options, payload) {
         inferDetailsFromExisting(wantBackend, haveBackend, codebaseUsesEnvs.includes(codebase));
         await (0, triggerRegionHelper_1.ensureTriggerRegions)(wantBackend);
         resolveCpuAndConcurrency(wantBackend);
+        resolveDefaultTimeout(wantBackend);
         validate.endpointsAreValid(wantBackend);
         inferBlockingDetails(wantBackend);
     }
@@ -225,40 +231,129 @@ async function prepare(context, options, payload) {
     validate.checkFiltersIntegrity(wantBackends, context.filters);
     (0, applyHash_1.applyBackendHashToBackends)(wantBackends, context);
 }
-function moveEndpointToRegion(backend, endpoint, region) {
-    endpoint.region = region;
-    backend.endpoints[region] = backend.endpoints[region] || {};
-    backend.endpoints[region][endpoint.id] = endpoint;
-    delete backend.endpoints[build.REGION_TBD][endpoint.id];
-    if (Object.keys(backend.endpoints[build.REGION_TBD]).length === 0) {
-        delete backend.endpoints[build.REGION_TBD];
+async function resolveDefaultRegionsForBuild(buildObj, have) {
+    for (const [id, endpoint] of Object.entries(buildObj.endpoints)) {
+        if (!endpoint.region?.length || endpoint.region.includes(build.REGION_TBD)) {
+            let resolvedRegion = exports.DEFAULT_FUNCTION_REGION;
+            let matching;
+            for (const region of Object.keys(have.endpoints)) {
+                if (have.endpoints[region][id]) {
+                    if (matching) {
+                        throw new error_1.FirebaseError(`Cannot resolve default region for function ${id}. It exists in multiple regions. The region must be specified to continue.`);
+                    }
+                    matching = have.endpoints[region][id];
+                }
+            }
+            if (matching) {
+                resolvedRegion = matching.region;
+            }
+            else {
+                try {
+                    const fullEndpoint = { ...endpoint, id };
+                    if (build.isBlockingTriggered(endpoint)) {
+                        resolvedRegion = resolveRegionForBlockingTrigger(fullEndpoint);
+                    }
+                    else if (build.isEventTriggered(endpoint)) {
+                        resolvedRegion = await resolveRegionForEventTrigger(fullEndpoint);
+                    }
+                }
+                catch (err) {
+                    logger_1.logger.debug(`Failed to resolve region for endpoint ${id}. Defaulting to ${exports.DEFAULT_FUNCTION_REGION}.`, (0, error_1.getErrStack)(err));
+                }
+            }
+            endpoint.region = [resolvedRegion];
+        }
     }
 }
-function matchRegionsForExisting(want, have) {
-    for (const [id, wantE] of Object.entries(want.endpoints[build.REGION_TBD] || {})) {
-        let matching;
-        for (const region of Object.keys(have.endpoints)) {
-            if (region === build.REGION_TBD) {
-                continue;
+function resolveRegionForBlockingTrigger(endpoint) {
+    const eventType = endpoint.blockingTrigger.eventType;
+    if (events.AUTH_BLOCKING_EVENTS.includes(eventType)) {
+        return "us-east1";
+    }
+    if ((0, ailogic_1.isGlobalAILogicEndpoint)(endpoint)) {
+        return "us-east1";
+    }
+    return exports.DEFAULT_FUNCTION_REGION;
+}
+async function resolveRegionForEventTrigger(endpoint) {
+    const eventTrigger = endpoint.eventTrigger;
+    const eventType = eventTrigger.eventType;
+    if (eventType.startsWith("google.cloud.pubsub.") ||
+        eventType.startsWith("providers/cloud.auth/eventTypes/") ||
+        eventType.startsWith("providers/firebase.auth/eventTypes/") ||
+        eventType.startsWith("google.firebase.testlab.") ||
+        eventType.startsWith("google.firebase.remoteconfig.") ||
+        eventType.startsWith("google.firebase.firebasealerts.")) {
+        return "us-east1";
+    }
+    if (eventType.startsWith("google.cloud.firestore.")) {
+        try {
+            const databaseId = eventTrigger.eventFilters?.database || "(default)";
+            const db = await (0, firestore_1.getDatabase)(endpoint.project, databaseId);
+            const locationId = db.locationId.toLowerCase();
+            if (locationId === "nam5" || locationId === "nam7")
+                return "us-central1";
+            if (locationId === "eur3")
+                return "europe-west1";
+            return locationId;
+        }
+        catch (err) {
+            logger_1.logger.debug("Failed to resolve Firestore database location", (0, error_1.getErrStack)(err));
+        }
+    }
+    if (eventType.startsWith("google.cloud.storage.")) {
+        try {
+            const bucketName = eventTrigger.eventFilters?.bucket;
+            if (bucketName) {
+                const bucket = await (0, storage_1.getBucket)(bucketName);
+                const locationId = bucket.location.toLowerCase();
+                if (locationId === "us")
+                    return "us-east1";
+                if (locationId === "eu")
+                    return "europe-west1";
+                if (locationId === "asia")
+                    return "asia-east1";
+                return locationId;
             }
-            if (have.endpoints[region][id]) {
-                if (matching) {
-                    throw new error_1.FirebaseError(`Cannot resolve default region for function ${id}. It exists in multiple regions. The region must be specified to continue.`);
+        }
+        catch (err) {
+            logger_1.logger.debug("Failed to resolve Cloud Storage bucket location", (0, error_1.getErrStack)(err));
+        }
+    }
+    if (eventType.startsWith("google.firebase.database.")) {
+        if (eventTrigger.region)
+            return eventTrigger.region;
+        try {
+            const instanceName = eventTrigger.eventFilters?.instance;
+            if (instanceName) {
+                const details = await (0, database_1.getDatabaseInstanceDetails)(endpoint.project, instanceName);
+                if (details.location && details.location !== "-") {
+                    return details.location.toLowerCase();
                 }
-                matching = have.endpoints[region][id];
             }
         }
-        if (!matching) {
-            continue;
+        catch (err) {
+            logger_1.logger.debug("Failed to resolve Realtime Database instance location", (0, error_1.getErrStack)(err));
         }
-        moveEndpointToRegion(want, wantE, matching.region);
     }
-}
-async function resolveDefaultRegions(want, have) {
-    matchRegionsForExisting(want, have);
-    for (const endpoint of Object.values(want.endpoints[build.REGION_TBD] || {})) {
-        moveEndpointToRegion(want, endpoint, "us-central1");
+    if (eventType.startsWith("google.firebase.dataconnect.")) {
+        if (eventTrigger.region)
+            return eventTrigger.region;
+        try {
+            const service = eventTrigger.eventFilters?.service;
+            if (service) {
+                return (0, names_1.parseServiceName)(service).location;
+            }
+            const connector = eventTrigger.eventFilters?.connector;
+            if (connector) {
+                return (0, names_1.parseConnectorName)(connector).location;
+            }
+        }
+        catch (err) {
+            logger_1.logger.debug("Failed to resolve DataConnect location", (0, error_1.getErrStack)(err));
+        }
     }
+    return exports.DEFAULT_FUNCTION_REGION;
 }
 function inferDetailsFromExisting(want, have, usedDotenv) {
     for (const wantE of backend.allEndpoints(want)) {
@@ -279,6 +374,9 @@ function inferDetailsFromExisting(want, have, usedDotenv) {
         if (typeof wantE.cpu === "undefined" && haveE.cpu) {
             wantE.cpu = haveE.cpu;
         }
+        if (typeof wantE.timeoutSeconds === "undefined" && haveE.timeoutSeconds) {
+            wantE.timeoutSeconds = haveE.timeoutSeconds;
+        }
         wantE.securityLevel = haveE.securityLevel ? haveE.securityLevel : "SECURE_ALWAYS";
         maybeCopyTriggerRegion(wantE, haveE);
     }
@@ -344,6 +442,13 @@ function resolveCpuAndConcurrency(want) {
         }
     }
 }
+function resolveDefaultTimeout(want) {
+    for (const e of backend.allEndpoints(want)) {
+        if (e.platform === "run" && e.timeoutSeconds === undefined) {
+            e.timeoutSeconds = backend.DEFAULT_TIMEOUT_SECONDS;
+        }
+    }
+}
 async function loadCodebases(config, options, firebaseConfig, runtimeConfig, filters) {
     const codebases = (0, functionsDeployHelper_1.targetCodebases)(config, filters);
     const projectId = (0, projectUtils_1.needProjectId)(options);

package/lib/deploy/functions/prepareFunctionsUpload.js

@@ -78,7 +78,7 @@ async function packageSource(projectDir, sourceDir, config, additionalSources, r
     const ignore = config.ignore || ["node_modules", ".git"];
     ignore.push("firebase-debug.log", "firebase-debug.*.log", CONFIG_DEST_FILE);
     try {
-        const files = await fsAsync.readdirRecursive({ path: sourceDir, ignore: ignore });
+        const files = await fsAsync.readdirRecursive({ path: sourceDir, ignoreStrings: ignore });
         hashes.push(...(await addFilesToArchive(archive, files, sourceDir, options?.executablePaths)));
         for (const name of additionalSources) {
             const absPath = utils.resolveWithin(projectDir, name);