puls-dev 0.1.0 → 0.1.8

package/dist/providers/firebase/functions.js

@@ -1,25 +1,25 @@
-import { execSync } from 'node:child_process';
-import { mkdtempSync, readFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { BaseBuilder } from '../../core/resource.js';
-import { cloudFetch, getProjectId } from './api.js';
-const CF_BASE = 'https://cloudfunctions.googleapis.com/v2';
+import { execSync } from "node:child_process";
+import { mkdtempSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { BaseBuilder } from "../../core/resource.js";
+import { cloudFetch, getProjectId } from "./api.js";
+const CF_BASE = "https://cloudfunctions.googleapis.com/v2";
 export const FUNCTIONS_RUNTIME = {
-    NODEJS_22: 'nodejs22',
-    NODEJS_20: 'nodejs20',
-    NODEJS_18: 'nodejs18',
-    PYTHON_312: 'python312',
-    PYTHON_311: 'python311',
-    GO_122: 'go122',
-    JAVA_21: 'java21',
+    NODEJS_22: "nodejs22",
+    NODEJS_20: "nodejs20",
+    NODEJS_18: "nodejs18",
+    PYTHON_312: "python312",
+    PYTHON_311: "python311",
+    GO_122: "go122",
+    JAVA_21: "java21",
 };
 export class FirebaseFunctionsBuilder extends BaseBuilder {
     _sourcePath;
-    _entryPoint = 'handler';
+    _entryPoint = "handler";
     _runtime = FUNCTIONS_RUNTIME.NODEJS_20;
-    _region = 'us-central1';
-    _memory = '256M';
+    _region = "us-central1";
+    _memory = "256M";
     _timeout = 60;
     _maxInstances = 100;
     _minInstances = 0;
@@ -29,15 +29,42 @@ export class FirebaseFunctionsBuilder extends BaseBuilder {
         // Discovery runs lazily in deploy() because we need _region, which may not be set at construction time
         this.discoveryPromise = Promise.resolve(null);
     }
-    source(path) { this._sourcePath = path; return this; }
-    entryPoint(e) { this._entryPoint = e; return this; }
-    runtime(r) { this._runtime = r; return this; }
-    region(r) { this._region = r; return this; }
-    memory(m) { this._memory = m; return this; }
-    timeout(seconds) { this._timeout = seconds; return this; }
-    maxInstances(n) { this._maxInstances = n; return this; }
-    minInstances(n) { this._minInstances = n; return this; }
-    env(vars) { this._env = vars; return this; }
+    source(path) {
+        this._sourcePath = path;
+        return this;
+    }
+    entryPoint(e) {
+        this._entryPoint = e;
+        return this;
+    }
+    runtime(r) {
+        this._runtime = r;
+        return this;
+    }
+    region(r) {
+        this._region = r;
+        return this;
+    }
+    memory(m) {
+        this._memory = m;
+        return this;
+    }
+    timeout(seconds) {
+        this._timeout = seconds;
+        return this;
+    }
+    maxInstances(n) {
+        this._maxInstances = n;
+        return this;
+    }
+    minInstances(n) {
+        this._minInstances = n;
+        return this;
+    }
+    env(vars) {
+        this._env = vars;
+        return this;
+    }
     fnPath() {
         return `/projects/${getProjectId()}/locations/${this._region}/functions/${this.name}`;
     }
@@ -46,7 +73,7 @@ export class FirebaseFunctionsBuilder extends BaseBuilder {
             return await cloudFetch(CF_BASE, this.fnPath());
         }
         catch (e) {
-            if (e.message?.includes('404'))
+            if (e.message?.includes("404"))
                 return null;
             throw e;
         }
@@ -54,17 +81,19 @@ export class FirebaseFunctionsBuilder extends BaseBuilder {
     zipSource() {
         if (!this._sourcePath)
             throw new Error(`[Firebase.Functions:${this.name}] .source() is required`);
-        const tmp = mkdtempSync(join(tmpdir(), 'puls-fn-'));
-        const zipPath = join(tmp, 'function.zip');
-        execSync(`cd "${this._sourcePath}" && zip -r "${zipPath}" .`, { stdio: 'pipe' });
+        const tmp = mkdtempSync(join(tmpdir(), "puls-fn-"));
+        const zipPath = join(tmp, "function.zip");
+        execSync(`cd "${this._sourcePath}" && zip -r "${zipPath}" .`, {
+            stdio: "pipe",
+        });
         return readFileSync(zipPath);
     }
     async uploadSource() {
-        const { uploadUrl, storageSource } = await cloudFetch(CF_BASE, `/projects/${getProjectId()}/locations/${this._region}/functions:generateUploadUrl`, { method: 'POST', body: '{}' });
+        const { uploadUrl, storageSource } = await cloudFetch(CF_BASE, `/projects/${getProjectId()}/locations/${this._region}/functions:generateUploadUrl`, { method: "POST", body: "{}" });
         const zipBuffer = this.zipSource();
         const res = await fetch(uploadUrl, {
-            method: 'PUT',
-            headers: { 'Content-Type': 'application/zip' },
+            method: "PUT",
+            headers: { "Content-Type": "application/zip" },
             body: new Uint8Array(zipBuffer),
         });
         if (!res.ok)
@@ -75,7 +104,7 @@ export class FirebaseFunctionsBuilder extends BaseBuilder {
         const start = Date.now();
         const timeout = 5 * 60 * 1000;
         while (Date.now() - start < timeout) {
-            await new Promise(r => setTimeout(r, 4000));
+            await new Promise((r) => setTimeout(r, 4000));
             const op = await cloudFetch(CF_BASE, `/${operationName}`);
             if (op.done) {
                 if (op.error)
@@ -94,7 +123,7 @@ export class FirebaseFunctionsBuilder extends BaseBuilder {
         if (dryRun) {
             const existing = await this.getExisting();
             if (existing) {
-                console.log(`   ✅ Function "${this.name}" exists (${existing.state ?? 'ACTIVE'})`);
+                console.log(`   ✅ Function "${this.name}" exists (${existing.state ?? "ACTIVE"})`);
                 console.log(`   📝 [PLAN] Update → ${this._runtime}, ${this._memory}, ${this._timeout}s timeout`);
             }
             else {
@@ -123,23 +152,27 @@ export class FirebaseFunctionsBuilder extends BaseBuilder {
                 maxInstanceCount: this._maxInstances,
                 minInstanceCount: this._minInstances,
                 environmentVariables: this._env,
-                ingressSettings: 'ALLOW_ALL',
+                ingressSettings: "ALLOW_ALL",
             },
         };
         const existing = await this.getExisting();
         let op;
         if (!existing) {
-            op = await cloudFetch(CF_BASE, `/projects/${project}/locations/${this._region}/functions?functionId=${this.name}`, { method: 'POST', body: JSON.stringify(body) });
+            op = await cloudFetch(CF_BASE, `/projects/${project}/locations/${this._region}/functions?functionId=${this.name}`, { method: "POST", body: JSON.stringify(body) });
             console.log(`   🚀 Creating function...`);
         }
         else {
-            const mask = 'buildConfig.source,buildConfig.runtime,buildConfig.entryPoint,buildConfig.environmentVariables,serviceConfig.availableMemory,serviceConfig.timeoutSeconds,serviceConfig.maxInstanceCount,serviceConfig.minInstanceCount,serviceConfig.environmentVariables';
-            op = await cloudFetch(CF_BASE, `${this.fnPath()}?updateMask=${mask}`, { method: 'PATCH', body: JSON.stringify(body) });
+            const mask = "buildConfig.source,buildConfig.runtime,buildConfig.entryPoint,buildConfig.environmentVariables,serviceConfig.availableMemory,serviceConfig.timeoutSeconds,serviceConfig.maxInstanceCount,serviceConfig.minInstanceCount,serviceConfig.environmentVariables";
+            op = await cloudFetch(CF_BASE, `${this.fnPath()}?updateMask=${mask}`, {
+                method: "PATCH",
+                body: JSON.stringify(body),
+            });
             console.log(`   🔄 Updating function...`);
         }
         await this.pollOperation(op.name);
         const fn = await this.getExisting();
-        const url = fn?.serviceConfig?.uri ?? `https://${this._region}-${project}.cloudfunctions.net/${this.name}`;
+        const url = fn?.serviceConfig?.uri ??
+            `https://${this._region}-${project}.cloudfunctions.net/${this.name}`;
         console.log(`   ✅ Function live → ${url}`);
         return { name: this.name, url, project, region: this._region };
     }
@@ -148,14 +181,14 @@ export class FirebaseFunctionsBuilder extends BaseBuilder {
         console.log(`\n🗑️  Destroying Firebase Function "${this.name}"...`);
         const existing = await this.getExisting();
         if (!existing) {
-            console.log(`   ✅ Function "${this.name}" does not exist — nothing to do`);
+            console.log(`   ✅ Function "${this.name}" does not exist - nothing to do`);
             return { destroyed: this.name };
         }
         if (dryRun) {
             console.log(`   📝 [PLAN] Delete function "${this.name}" in ${this._region}`);
             return { destroyed: this.name };
         }
-        const op = await cloudFetch(CF_BASE, this.fnPath(), { method: 'DELETE' });
+        const op = await cloudFetch(CF_BASE, this.fnPath(), { method: "DELETE" });
         await this.pollOperation(op.name);
         console.log(`   ✅ Function "${this.name}" deleted`);
         return { destroyed: this.name };

package/dist/providers/firebase/hosting.d.ts

@@ -1,4 +1,4 @@
-import { BaseBuilder } from '../../core/resource.js';
+import { BaseBuilder } from "../../core/resource.js";
 export declare class FirebaseHostingBuilder extends BaseBuilder {
     private _sourcePath?;
     constructor(siteId: string);

package/dist/providers/firebase/hosting.js

@@ -1,22 +1,23 @@
-import { createHash } from 'node:crypto';
-import { readdirSync, statSync, readFileSync } from 'node:fs';
-import { join, relative, extname } from 'node:path';
-import { BaseBuilder } from '../../core/resource.js';
-import { getProjectId, hostingFetch, getFirebaseToken } from './api.js';
+import { createHash } from "node:crypto";
+import { readdirSync, statSync, readFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import { gzipSync } from "node:zlib";
+import { BaseBuilder } from "../../core/resource.js";
+import { getProjectId, hostingFetch, getFirebaseToken } from "./api.js";
 const CONTENT_TYPES = {
-    '.html': 'text/html',
-    '.css': 'text/css',
-    '.js': 'application/javascript',
-    '.json': 'application/json',
-    '.png': 'image/png',
-    '.jpg': 'image/jpeg',
-    '.svg': 'image/svg+xml',
-    '.ico': 'image/x-icon',
-    '.woff2': 'font/woff2',
-    '.woff': 'font/woff',
-    '.ttf': 'font/ttf',
-    '.txt': 'text/plain',
-    '.xml': 'application/xml',
+    ".html": "text/html",
+    ".css": "text/css",
+    ".js": "application/javascript",
+    ".json": "application/json",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".svg": "image/svg+xml",
+    ".ico": "image/x-icon",
+    ".woff2": "font/woff2",
+    ".woff": "font/woff",
+    ".ttf": "font/ttf",
+    ".txt": "text/plain",
+    ".xml": "application/xml",
 };
 function walkDir(dir) {
     const results = [];
@@ -33,7 +34,7 @@ function walkDir(dir) {
 }
 function sha256(filePath) {
     const content = readFileSync(filePath);
-    return createHash('sha256').update(content).digest('hex');
+    return createHash("sha256").update(content).digest("hex");
 }
 export class FirebaseHostingBuilder extends BaseBuilder {
     _sourcePath;
@@ -42,17 +43,21 @@ export class FirebaseHostingBuilder extends BaseBuilder {
         // Discovery: check if the site has any releases (confirms it exists and is active)
         this.discoveryPromise = this.discoverSite(siteId);
     }
-    source(path) { this._sourcePath = path; return this; }
+    source(path) {
+        this._sourcePath = path;
+        return this;
+    }
     async discoverSite(siteId) {
         try {
-            const result = await hostingFetch(`/sites/${siteId}/releases?pageSize=1`);
-            return result ?? null;
+            const projectId = getProjectId();
+            const result = await hostingFetch(`/projects/${projectId}/sites/${siteId}`);
+            return result;
         }
         catch (e) {
-            // Site doesn't exist yet or credentials not set yet — not an error at construction time
-            if (e.message?.includes('403') || e.message?.includes('404'))
+            // Site doesn't exist yet or credentials not set yet - not an error at construction time
+            if (e.message?.includes("403") || e.message?.includes("404"))
                 return null;
-            if (e.message?.includes('Firebase not configured'))
+            if (e.message?.includes("Firebase not configured"))
                 return null;
             throw e;
         }
@@ -61,14 +66,18 @@ export class FirebaseHostingBuilder extends BaseBuilder {
         const dryRun = this.isDryRunActive();
         const projectId = getProjectId();
         const siteId = this.name;
+        const parent = `projects/${projectId}/sites/${siteId}`;
         console.log(`\n⚡ Finalizing Firebase Hosting "${siteId}"...`);
         if (!this._sourcePath)
             throw new Error(`[Firebase.Hosting:${siteId}] .source("./dist") is required`);
         const files = walkDir(this._sourcePath);
         if (files.length === 0)
             throw new Error(`[Firebase.Hosting:${siteId}] No files found in "${this._sourcePath}"`);
+        const existing = await this.discoveryPromise;
         if (dryRun) {
             console.log(`   📝 [PLAN] Deploy ${files.length} file(s) to https://${siteId}.web.app`);
+            if (!existing)
+                console.log(`      └─ Will create secondary site "${siteId}"`);
             for (const f of files.slice(0, 5)) {
                 console.log(`      └─ /${relative(this._sourcePath, f)}`);
             }
@@ -76,52 +85,83 @@ export class FirebaseHostingBuilder extends BaseBuilder {
                 console.log(`      └─ ... and ${files.length - 5} more`);
             return { siteId, url: `https://${siteId}.web.app` };
         }
+        // 0. Ensure site exists (for secondary sites)
+        if (!existing) {
+            console.log(`   🆕 Creating secondary site "${siteId}"...`);
+            try {
+                await hostingFetch(`/projects/${projectId}/sites?siteId=${siteId}`, {
+                    method: "POST",
+                    body: JSON.stringify({}), // Defaults to USER_SITE
+                });
+            }
+            catch (e) {
+                if (!e.message.includes("409"))
+                    throw e;
+            }
+        }
         // 1. Create a new version
-        const version = await hostingFetch(`/sites/${siteId}/versions`, {
-            method: 'POST',
-            body: JSON.stringify({ config: { headers: [{ glob: '**', headers: { 'Cache-Control': 'max-age=3600' } }] } }),
+        const version = await hostingFetch(`/${parent}/versions`, {
+            method: "POST",
+            body: JSON.stringify({
+                config: {
+                    headers: [
+                        { glob: "**", headers: { "Cache-Control": "max-age=3600" } },
+                    ],
+                },
+            }),
         });
-        const versionId = version.name.split('/').pop();
+        const versionId = version.name.split("/").pop();
         console.log(`   📦 Version created: ${versionId}`);
-        // 2. Build file hash map — keys are URL paths, values are SHA256 hashes
+        // 2. Build file hash map - keys are URL paths, values are SHA256 hashes
+        // NOTE: Firebase Hosting requires gzipped content and the hash must match the gzipped bytes.
         const fileMap = {};
-        const absoluteToUrl = {};
+        const absoluteToCompressed = {};
+        const hashToUrl = {};
         for (const absPath of files) {
-            const urlPath = '/' + relative(this._sourcePath, absPath).replace(/\\/g, '/');
-            const hash = sha256(absPath);
+            const urlPath = "/" + relative(this._sourcePath, absPath).replace(/\\/g, "/");
+            const content = readFileSync(absPath);
+            const compressed = gzipSync(content);
+            const hash = createHash("sha256").update(compressed).digest("hex");
             fileMap[urlPath] = hash;
-            absoluteToUrl[hash] = absPath;
+            absoluteToCompressed[absPath] = compressed;
+            hashToUrl[hash] = absPath;
         }
-        // 3. Populate files — API tells us which hashes need uploading
-        const populate = await hostingFetch(`/sites/${siteId}/versions/${versionId}/populateFiles`, {
-            method: 'POST',
+        // 3. Populate files - API tells us which hashes need uploading
+        const populate = await hostingFetch(`/${parent}/versions/${versionId}:populateFiles`, {
+            method: "POST",
             body: JSON.stringify({ files: fileMap }),
         });
         const uploadUrl = populate.uploadUrl;
         const required = populate.uploadRequiredHashes ?? [];
         console.log(`   📤 Uploading ${required.length} file(s) (${files.length - required.length} cached)`);
         // 4. Upload each required file
-        const token = await getFirebaseToken(['https://www.googleapis.com/auth/firebase.hosting']);
+        const token = await getFirebaseToken([
+            "https://www.googleapis.com/auth/firebase.hosting",
+        ]);
         for (const hash of required) {
-            const absPath = absoluteToUrl[hash];
-            const content = readFileSync(absPath);
-            const contentType = CONTENT_TYPES[extname(absPath).toLowerCase()] ?? 'application/octet-stream';
+            const absPath = hashToUrl[hash];
+            const compressed = absoluteToCompressed[absPath];
             const res = await fetch(`${uploadUrl}/${hash}`, {
-                method: 'POST',
-                headers: { 'Authorization': `Bearer ${token}`, 'Content-Type': contentType },
-                body: content,
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                    "Content-Type": "application/octet-stream",
+                },
+                body: compressed,
             });
-            if (!res.ok)
-                throw new Error(`Upload failed for ${absPath}: ${res.status}`);
+            if (!res.ok) {
+                const errorBody = await res.text();
+                throw new Error(`Upload failed for ${absPath}: ${res.status} - ${errorBody}`);
+            }
         }
         // 5. Finalize the version
-        await hostingFetch(`/sites/${siteId}/versions/${versionId}`, {
-            method: 'PATCH',
-            body: JSON.stringify({ status: 'FINALIZED' }),
+        await hostingFetch(`/${parent}/versions/${versionId}`, {
+            method: "PATCH",
+            body: JSON.stringify({ status: "FINALIZED" }),
         });
         // 6. Create a release
-        await hostingFetch(`/sites/${siteId}/releases?versionName=sites/${siteId}/versions/${versionId}`, {
-            method: 'POST',
+        await hostingFetch(`/${parent}/releases?versionName=${parent}/versions/${versionId}`, {
+            method: "POST",
             body: JSON.stringify({}),
         });
         const url = `https://${siteId}.web.app`;
@@ -135,7 +175,7 @@ export class FirebaseHostingBuilder extends BaseBuilder {
             console.log(`   📝 [PLAN] Delete all releases for site "${this.name}"`);
             return { destroyed: this.name };
         }
-        // Firebase doesn't support deleting the default site — we can only roll back releases.
+        // Firebase doesn't support deleting the default site - we can only roll back releases.
         // For non-default sites, the Sites API supports deletion (requires Blaze plan).
         console.log(`   ℹ️  Firebase Hosting sites cannot be deleted via API (default site is permanent).`);
         console.log(`      To unpublish, go to the Firebase console and disable Hosting.`);

package/dist/providers/firebase/remoteconfig.d.ts

@@ -1,4 +1,4 @@
-import { BaseBuilder } from '../../core/resource.js';
+import { BaseBuilder } from "../../core/resource.js";
 type ParamValue = string | number | boolean | object;
 export declare class FirebaseRemoteConfigBuilder extends BaseBuilder {
     private _params;

package/dist/providers/firebase/remoteconfig.js

@@ -1,43 +1,43 @@
-import { BaseBuilder } from '../../core/resource.js';
-import { getFirebaseToken, getProjectId } from './api.js';
-const RC_BASE = 'https://firebaseremoteconfig.googleapis.com/v1';
-const RC_SCOPE = 'https://www.googleapis.com/auth/firebase.remoteconfig';
+import { BaseBuilder } from "../../core/resource.js";
+import { getFirebaseToken, getProjectId } from "./api.js";
+const RC_BASE = "https://firebaseremoteconfig.googleapis.com/v1";
+const RC_SCOPE = "https://www.googleapis.com/auth/firebase.remoteconfig";
 function inferType(v) {
-    if (typeof v === 'boolean')
-        return 'BOOLEAN';
-    if (typeof v === 'number')
-        return 'NUMBER';
-    if (typeof v === 'object')
-        return 'JSON';
-    return 'STRING';
+    if (typeof v === "boolean")
+        return "BOOLEAN";
+    if (typeof v === "number")
+        return "NUMBER";
+    if (typeof v === "object")
+        return "JSON";
+    return "STRING";
 }
 function serialize(v) {
-    return typeof v === 'object' ? JSON.stringify(v) : String(v);
+    return typeof v === "object" ? JSON.stringify(v) : String(v);
 }
 export class FirebaseRemoteConfigBuilder extends BaseBuilder {
     _params = [];
     _conditions = [];
     constructor() {
-        super('remoteconfig');
+        super("remoteconfig");
         this.discoveryPromise = Promise.resolve(null);
     }
     string(key, value, description) {
-        this._params.push({ key, value, type: 'STRING', description });
+        this._params.push({ key, value, type: "STRING", description });
         return this;
     }
     bool(key, value, description) {
-        this._params.push({ key, value, type: 'BOOLEAN', description });
+        this._params.push({ key, value, type: "BOOLEAN", description });
         return this;
     }
     number(key, value, description) {
-        this._params.push({ key, value, type: 'NUMBER', description });
+        this._params.push({ key, value, type: "NUMBER", description });
         return this;
     }
     json(key, value, description) {
-        this._params.push({ key, value, type: 'JSON', description });
+        this._params.push({ key, value, type: "JSON", description });
         return this;
     }
-    // Generic param — type inferred from value
+    // Generic param - type inferred from value
     param(key, value, description) {
         this._params.push({ key, value, type: inferType(value), description });
         return this;
@@ -48,9 +48,9 @@ export class FirebaseRemoteConfigBuilder extends BaseBuilder {
     }
     // Override a param's value for a specific condition
     override(paramKey, conditionName, value) {
-        const p = this._params.find(p => p.key === paramKey);
+        const p = this._params.find((p) => p.key === paramKey);
         if (!p)
-            throw new Error(`[RemoteConfig] param "${paramKey}" not defined — call .param()/.bool()/etc. first`);
+            throw new Error(`[RemoteConfig] param "${paramKey}" not defined - call .param()/.bool()/etc. first`);
         p.conditionalValues ??= {};
         p.conditionalValues[conditionName] = value;
         return this;
@@ -59,18 +59,21 @@ export class FirebaseRemoteConfigBuilder extends BaseBuilder {
     async rcFetch(path, opts = {}) {
         const token = await getFirebaseToken([RC_SCOPE]);
         const headers = {
-            'Authorization': `Bearer ${token}`,
-            'Content-Type': 'application/json',
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json",
         };
         if (opts.etag)
-            headers['If-Match'] = opts.etag;
+            headers["If-Match"] = opts.etag;
         const res = await fetch(`${RC_BASE}${path}`, { ...opts, headers });
         if (!res.ok) {
             const body = await res.text();
-            throw new Error(`RemoteConfig API ${opts.method ?? 'GET'} ${path} → ${res.status}: ${body}`);
+            throw new Error(`RemoteConfig API ${opts.method ?? "GET"} ${path} → ${res.status}: ${body}`);
         }
         const text = await res.text();
-        return { data: text ? JSON.parse(text) : null, etag: res.headers.get('etag') };
+        return {
+            data: text ? JSON.parse(text) : null,
+            etag: res.headers.get("etag"),
+        };
     }
     // ── Deploy ────────────────────────────────────────────────────────────────
     async deploy() {
@@ -80,7 +83,9 @@ export class FirebaseRemoteConfigBuilder extends BaseBuilder {
         if (dryRun) {
             console.log(`   📝 [PLAN] Set ${this._params.length} parameter(s):`);
             for (const p of this._params) {
-                const overrides = p.conditionalValues ? ` + ${Object.keys(p.conditionalValues).length} override(s)` : '';
+                const overrides = p.conditionalValues
+                    ? ` + ${Object.keys(p.conditionalValues).length} override(s)`
+                    : "";
                 console.log(`      └─ ${p.key} (${p.type}): ${serialize(p.value)}${overrides}`);
             }
             if (this._conditions.length) {
@@ -92,7 +97,7 @@ export class FirebaseRemoteConfigBuilder extends BaseBuilder {
         }
         // Fetch current template + ETag
         const { data: current, etag } = await this.rcFetch(`/projects/${project}/remoteConfig`);
-        // Merge our params into the existing template (non-destructive — preserves params we didn't define)
+        // Merge our params into the existing template (non-destructive - preserves params we didn't define)
         const parameters = { ...(current?.parameters ?? {}) };
         for (const p of this._params) {
             const entry = {
@@ -114,13 +119,17 @@ export class FirebaseRemoteConfigBuilder extends BaseBuilder {
         const existingNames = new Set(existingConditions.map((c) => c.name));
         const conditions = [
             ...existingConditions,
-            ...this._conditions.filter(c => !existingNames.has(c.name)),
+            ...this._conditions.filter((c) => !existingNames.has(c.name)),
         ];
-        const body = { parameters, conditions, parameterGroups: current?.parameterGroups ?? {} };
+        const body = {
+            parameters,
+            conditions,
+            parameterGroups: current?.parameterGroups ?? {},
+        };
         await this.rcFetch(`/projects/${project}/remoteConfig`, {
-            method: 'PUT',
+            method: "PUT",
             body: JSON.stringify(body),
-            etag: etag ?? '*',
+            etag: etag ?? "*",
         });
         console.log(`   ✅ ${this._params.length} parameter(s) published`);
         if (this._conditions.length)
@@ -129,7 +138,7 @@ export class FirebaseRemoteConfigBuilder extends BaseBuilder {
     }
     async destroy() {
         console.log(`\n🗑️  Destroying Firebase RemoteConfig...`);
-        console.log(`   ℹ️  RemoteConfig templates cannot be deleted via API — clear parameters in the Firebase console`);
-        return { destroyed: 'remoteconfig' };
+        console.log(`   ℹ️  RemoteConfig templates cannot be deleted via API - clear parameters in the Firebase console`);
+        return { destroyed: "remoteconfig" };
     }
 }

package/dist/providers/firebase/storage.d.ts

@@ -1,4 +1,4 @@
-import { BaseBuilder } from '../../core/resource.js';
+import { BaseBuilder } from "../../core/resource.js";
 interface CorsRule {
     origin: string[];
     method: string[];