@microteia/console 2.22.1 → 2.24.0

package/CONSOLE-VERSIONS.md

@@ -22,6 +22,14 @@
 - fix(command): what was broken, and what it did to whoever hit it.
 -->
 
+#### [2.24.0] — 2026-10-07
+
+- feat(export-catalog): each screen in `installed-catalog.json` now carries its `sourceId`. The snapshot only had the installed key, which may have been disambiguated on install, so an extension that adds a tab to another's record detail (`record:<sourceId>`) could not be checked against the installation. Older snapshots simply lack the field.
+
+#### [2.23.0] — 2026-10-07
+
+- fix(provision): `microteia provision` run on its own now probes the deployed stamps itself instead of concluding that nothing changed. It could only compare stamps with the map `deploy` hands it, and running alone — the path of anyone who has just swapped kernels with `unpack` — there was no map: `outdatedByStamp` drew no conclusion, the function stayed out of the queue, and the record said "applied" because it genuinely was running, from the previous package. An office upgraded this way kept serving an extension's old Cloud Function with nothing anywhere saying so; the symptom surfaced in the client, not in the Console. The queue is now everything the installed extensions claim, and `deployFunctionsThatChanged` — the same probe `deploy` uses — decides what actually goes up: one reference function per stamp, and the rest left alone when it comes back unchanged. What the probe skips counts as satisfied, or a complete installation would stay "pending" forever.
+
 #### [2.22.1] — 2026-09-19
 
 - fix(cli/publish): the release notes now carry every changelog entry since the last PUBLISHED version,

package/README.md

@@ -1,4 +1,4 @@
-# Microteia Console 2.22.1
+# Microteia Console 2.24.0
 
 Installs and updates Microteia in a Firebase project you own. It has no npm dependencies of its own —
 what it needs are command-line tools that are already on the machine, listed at the bottom.

package/lib/console/exportCatalog.d.ts

@@ -58,6 +58,11 @@ export interface CatalogFieldExport {
 }
 export interface CatalogScreenExport {
     key: string;
+    /**
+     * O id UNIVERSAL da tela. A chave acima é a instalada, que pode ter sido desambiguada; é pelo
+     * `sourceId` que uma extensão endereça a tela de outra (`record:<sourceId>`).
+     */
+    sourceId?: string;
     collection?: string;
     titleSingular: string;
     titlePlural?: string;

package/lib/console/exportCatalog.js

@@ -121,6 +121,7 @@ const screenExport = (document) => {
     const fields = Array.isArray(data.fields) ? data.fields : [];
     return {
         key: document.id,
+        ...(text(data.sourceId) === undefined ? {} : { sourceId: text(data.sourceId) }),
         ...(text(data.dataCollection) === undefined ? {} : { collection: text(data.dataCollection) }),
         titleSingular: text(data.titleSingular) ?? document.id,
         ...(text(data.titlePlural) === undefined ? {} : { titlePlural: text(data.titlePlural) }),

package/lib/console/provision.js

@@ -10,6 +10,7 @@ import { changedParameters, functionsDeclaringParameters, parameterDigests, pars
 import { ENVIRONMENT_FILE, readEnvironment, writeEnvironment } from './environment.js';
 import { FIREBASE_BIN } from './firebaseCli.js';
 import { deployFunctionsOneByOne, reportFailures, reportNotices } from './deployFunctions.js';
+import { deployFunctionsThatChanged } from './functionsUpToDate.js';
 import { clearRegionOrphans, listDeployedFunctions } from './regionOrphans.js';
 import { outdatedByStamp } from './functionsUpToDate.js';
 import { checkCallables, invokerGrantCommand } from './callableAccess.js';
@@ -363,7 +364,28 @@ export const provisionBackend = async (options) => {
         info('  Cloud Function at ITS deploy, so a function already running keeps the previous one.');
         blank();
     }
-    const queued = wantedFunctions.filter((name) => options.all === true || !appliedNames.has(name) || staleFunctions.has(name));
+    /**
+     * De onde vem a conclusão sobre o que mudou — e são DOIS caminhos, porque as duas situações são
+     * diferentes de verdade.
+     *
+     * Vindo do `deploy`, o carimbo de agora já foi observado: as functions do kernel acabaram de subir,
+     * e as de extensão estão no MESMO codebase, então `outdatedByStamp` decide sem sondar nada.
+     *
+     * Rodando SOZINHO — que é o caminho de quem acabou de trocar de kernel por `unpack` — não há mapa
+     * nenhum, e era aqui que estava o defeito: `outdatedByStamp` não tinha com o que comparar, não
+     * tirava conclusão, e a function de extensão cujo CÓDIGO mudou ficava de fora da fila para sempre.
+     * O registro dizia "aplicada", porque ela de fato estava no ar — só que da versão anterior. Nada
+     * avisava, e o sintoma aparecia no cliente, não aqui.
+     *
+     * Então a fila passa a ser TUDO o que as extensões pedem, e quem decide o que realmente sobe é
+     * `deployFunctionsThatChanged` — a mesma sondagem do `deploy`, pela mesma função: deploya uma
+     * referência por carimbo e, se o carimbo voltar igual, deixa as outras em paz. Custa uma function
+     * por execução; não custar nada era o que fazia a conta ficar errada.
+     */
+    const probing = options.refreshedStamps === undefined;
+    const queued = probing
+        ? wantedFunctions
+        : wantedFunctions.filter((name) => options.all === true || !appliedNames.has(name) || staleFunctions.has(name));
     /**
      * A recusa do portão, cobrada de quem está na fila — e só dela.
      *
@@ -382,6 +404,8 @@ export const provisionBackend = async (options) => {
         info('  they are the only ones held back. Fix the guard and run "microteia provision" again.');
         outcome.failed.push(...refused);
     }
+    /** O que já estava no ar com ESTE código, e por isso não subiu. Conta como satisfeito. */
+    let skippedNow = [];
     if (toDeploy.length === 0) {
         // Anunciar "as 0 functions já estão deployadas" seria o preço de ter tirado o desvio, e não é
         // preciso pagá-lo: quando não há exigência nenhuma, quem já falou foi a linha lá em cima.
@@ -405,17 +429,27 @@ export const provisionBackend = async (options) => {
         // A extensão que mudou de região deixa a cópia antiga para trás igual ao kernel, e ali o efeito
         // é o mesmo: deploy recusado em toda tentativa, e gatilho disparando em duas regiões.
         await clearRegionOrphans(projectId, toDeploy, region, options.prune, await projectFunctions());
-        info(`  deploying ${toDeploy.length} function(s), one at a time…`);
-        const report = await deployFunctionsOneByOne(toDeploy, {
-            projectId, cwd: install, delaySeconds, force: false,
-        });
+        const deployOptions = { projectId, cwd: install, delaySeconds, force: false };
+        if (!probing)
+            info(`  deploying ${toDeploy.length} function(s), one at a time…`);
+        const report = probing
+            ? await deployFunctionsThatChanged(toDeploy, deployOptions, {
+                deployed: await projectFunctions(),
+                region,
+                all: options.all === true,
+            })
+            : { ...await deployFunctionsOneByOne(toDeploy, deployOptions), skipped: [] };
+        skippedNow = report.skipped;
         outcome.deployed = report.deployed;
         outcome.failed.push(...report.failed.map((entry) => entry.name));
         reportFailures(report.failed);
         reportNotices(report.notices);
         await checkNewCallables([...(manifest.callables ?? []), ...office.callables], report.deployed, projectId, region);
     }
-    const deployedNow = new Set([...appliedNames, ...outcome.deployed]);
+    // O PULADO entra junto: ele não subiu agora porque o projeto já roda exatamente este código, que é
+    // o mesmo que estar satisfeito. Deixá-lo de fora manteria a extensão "pendente" para sempre numa
+    // instalação em que não falta nada.
+    const deployedNow = new Set([...appliedNames, ...outcome.deployed, ...skippedNow]);
     for (const claim of valid) {
         const satisfied = (claim.backend.functions ?? []).every((name) => deployedNow.has(name));
         if (satisfied) {

package/lib/shared/paths.d.ts

@@ -87,4 +87,4 @@ export declare const consoleRoot: string;
  * de código nunca chegou a quem instala. Este bloco fica sendo o que ele já era antes de crescer: a
  * política de semver da ferramenta, mais o registro do que motivou as versões até a `2.5.0`.
  */
-export declare const CLI_VERSION = "2.22.1";
+export declare const CLI_VERSION = "2.24.0";

package/lib/shared/paths.js

@@ -94,4 +94,4 @@ export const consoleRoot = resolve(here, '..', '..');
  * de código nunca chegou a quem instala. Este bloco fica sendo o que ele já era antes de crescer: a
  * política de semver da ferramenta, mais o registro do que motivou as versões até a `2.5.0`.
  */
-export const CLI_VERSION = '2.22.1';
+export const CLI_VERSION = '2.24.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@microteia/console",
-  "version": "2.22.1",
+  "version": "2.24.0",
   "description": "Install and update Microteia in a Firebase project you own.",
   "license": "UNLICENSED",
   "type": "module",