@microteia/console 2.38.0 → 2.42.0

package/NOTICE

@@ -0,0 +1,97 @@
+Microteia — An AI-First Business Application Platform
+Copyright (C) 2026 Alexnaldo Carvalho dos Santos and the Microteia contributors
+Source code: https://github.com/microteia/microteia
+
+This program is free software: you can redistribute it and/or modify it under the terms of the
+GNU Affero General Public License as published by the Free Software Foundation, either version 3 of
+the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero
+General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License along with this program, in
+the file LICENSE. If not, see <https://www.gnu.org/licenses/>.
+
+The license is supplemented by the additional terms and the additional permission below, as allowed
+by section 7 of the GNU Affero General Public License. Both apply to every copy of Microteia and to
+every work based on it, and this file must be conveyed together with the LICENSE file.
+
+
+===================================================================================================
+ADDITIONAL TERMS UNDER SECTION 7 OF THE GNU AFFERO GENERAL PUBLIC LICENSE
+===================================================================================================
+
+1. Attribution — section 7(b).
+
+   Every copy of Microteia, modified or not, that is conveyed or that users interact with remotely
+   over a computer network, must preserve the copyright notices and display the following
+   attribution, unaltered and legible:
+
+       Based on Microteia — https://github.com/microteia/microteia
+       Copyright (C) Alexnaldo Carvalho dos Santos and the Microteia contributors.
+       Licensed under the GNU Affero General Public License, version 3 or later.
+
+   The attribution must appear (a) in the Appropriate Legal Notices displayed by the interactive user
+   interface — in Microteia, the "Copyright and contact" section of the Terms of Use page, served at
+   the "/license" route, which is reachable before signing in — and (b) in the README, or equivalent
+   documentation, of every distribution. A translated interface may display the attribution in its
+   own language, provided the link and the names are kept.
+
+2. Marking of modified versions — section 7(c).
+
+   A modified version must be marked in reasonable ways as different from the original version, and
+   must not misrepresent its origin: it must not be presented as the original Microteia, nor as made,
+   endorsed or supported by its author or contributors.
+
+3. Trade names and trademarks — section 7(e).
+
+   This license grants no rights under trademark law to the name "Microteia", to its logos or to any
+   other brand identifier, beyond the use required to comply with the attribution in term 1 and to
+   state truthfully that a work is based on Microteia.
+
+
+===================================================================================================
+ADDITIONAL PERMISSION UNDER SECTION 7 — MICROTEIA EXTENSION EXCEPTION
+===================================================================================================
+
+Microteia is built to be extended without being modified. As a special exception, the copyright
+holders of Microteia give you permission to create an Extension, and to use, convey, sell and offer
+it to users over a computer network, under terms of your choice — proprietary, permissive or
+copyleft — and to run it together with Microteia, without the Extension, or the combination of the
+Extension with Microteia, being subject to the terms of the GNU Affero General Public License as to
+the Extension, provided that the Extension interacts with Microteia only through the Published
+Interfaces.
+
+"Extension" means a plugin, extension package, module, theme, language package, view, startup
+script, sandbox script, workflow, document template, or Cloud Function — together with its source
+code and with every artifact compiled from it — that is not itself part of Microteia and that is
+written to be installed in, or deployed beside, an installation of Microteia.
+
+"Published Interfaces" means:
+
+  a. the extension package format — the manifest, its extension points and the artifact that the
+     platform validates and installs;
+  b. the authoring SDK, published as "@microteia/sdk", including its command-line tools and its type
+     definitions;
+  c. the curated host API offered to extension views and startup scripts (the "@microteia/*"
+     modules described by the SDK type definitions);
+  d. the API offered to sandbox scripts;
+  e. the office functions API (the "office" entry point of the platform's functions package), and the
+     directories in which an installation mounts its own Cloud Functions;
+  f. the Model Context Protocol server and the callable functions that the platform exposes to
+     external clients.
+
+You may also copy code from the authoring examples that are distributed with the SDK (the
+"examples" directory of the SDK package and the first-party extensions it is built from) into an
+Extension, and convey that copied code as part of the Extension, under the Extension's terms.
+
+This exception does not cover modifications of Microteia itself. A change to the kernel, to a
+first-party plugin, to the SDK or to any other part of Microteia — including a change made in order
+to support an Extension — is a modification of Microteia and remains subject to the GNU Affero
+General Public License and to the additional terms above. The exception also grants no right to use
+the Microteia name or trademarks for an Extension beyond stating truthfully that the Extension works
+with Microteia.
+
+If you modify Microteia, you may extend this exception to your version, but you are not obligated to
+do so. If you do not wish to do so, delete this exception statement from your version.

package/README.md

@@ -1,4 +1,4 @@
-# Microteia Console 2.38.0
+# Microteia Console 2.42.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.
@@ -64,3 +64,10 @@ the Microteia repository.
 
 `CONSOLE-VERSIONS.md`, in this folder. `unpack` copies it into the installation it manages, beside the
 platform's own `KERNEL-VERSIONS.md` — each history travels with the artifact it describes.
+
+## License
+
+Free software, licensed under the GNU Affero General Public License, version 3 or (at your option) any
+later version — the full text is in `LICENSE`, and the additional terms in `NOTICE`, in this folder.
+The source code of this Console and of the platform it installs is at
+https://github.com/microteia/microteia.

package/lib/console/backendApplied.d.ts

@@ -0,0 +1,58 @@
+import type { FirestoreTypedValue } from './firestoreRest.js';
+/**
+ * O que o PROJETO tem aplicado, devolvido ao banco onde a aplicação pode ler.
+ *
+ * O carimbo mora em cada cópia instalada (`backendState`), e o `provision` o grava nas cópias que
+ * existem no momento em que roda. A cópia que chega DEPOIS — o segundo escritório que atualiza para a
+ * versão que o primeiro já pôs no ar — ficava "Backend pendente" até alguém rodar o comando de novo, e o
+ * comando não decidia nada: a aprovação por hash já é do projeto e as functions já estavam no ar. Ele
+ * só copiava um registro.
+ *
+ * Este documento é esse registro, uma vez por projeto: para cada extensão, o fingerprint que o projeto
+ * roda. A tela libera a cópia cujo fingerprint está aqui. Quem afirma continua sendo só o Console — a
+ * regra de `backend_state` nega escrita ao cliente.
+ */
+export declare const BACKEND_APPLIED_PATH = "/backend_state/applied";
+export interface AppliedEntry {
+    pluginId: string;
+    fingerprint: string;
+    approvedHash?: string;
+    approvedBy?: string;
+}
+/** O que uma cópia exige, na forma mínima que as contas abaixo precisam. */
+export interface FingerprintClaim {
+    pluginId: string;
+    fingerprint: string;
+}
+/**
+ * Os campos do documento, montados sem tocar na rede.
+ *
+ * Lista e não mapa por `pluginId` porque o id tem pontos, e ponto em chave de mapa vira caminho de
+ * campo no Firestore. A FORMA é contrato com o kernel, versionado à parte — é o que o teste confere.
+ */
+export declare const backendAppliedFields: (entries: readonly AppliedEntry[], writtenAt: Date) => Record<string, FirestoreTypedValue>;
+/**
+ * O documento lido, defensivo pelo mesmo motivo do lado do kernel: pode ter sido escrito por um Console
+ * de outra versão. Entrada sem id ou sem fingerprint não libera nada, então é descartada.
+ */
+export declare const parseBackendApplied: (data: Record<string, unknown> | null) => AppliedEntry[];
+export declare const appliedEntryOf: (entries: readonly AppliedEntry[], claim: FingerprintClaim) => AppliedEntry | undefined;
+/**
+ * O que continua verdadeiro aconteça o que acontecer nesta execução.
+ *
+ * Só fica a entrada de extensão ainda instalada E com o fingerprint da cópia mais nova — a que o
+ * deploy vai pôr no ar. A extensão que saiu de todo escritório pode ter a function apagada pelo
+ * `--prune`; a versão superada pode ter o código trocado pelo deploy. Nos dois casos a entrada
+ * anunciaria no ar o que talvez não esteja, e uma cópia nova nasceria liberada contra uma function que
+ * não existe — o defeito que parece CORS e que a pendência existe para impedir.
+ *
+ * Só REMOVE: acrescentar é do fim da execução, quando o deploy já respondeu.
+ */
+export declare const reduceBackendApplied: (entries: readonly AppliedEntry[], newest: readonly FingerprintClaim[]) => AppliedEntry[];
+/**
+ * `[]` quando o documento não existe. Leitura recusada também vira `[]`, com aviso de quem chama: o
+ * que se perde é só o atalho — sem entradas, nada é materializado, e a redução grava a lista vazia,
+ * que é a resposta segura para "não sei o que o projeto tem".
+ */
+export declare const readBackendApplied: (projectId: string) => Promise<AppliedEntry[]>;
+export declare const writeBackendApplied: (projectId: string, entries: readonly AppliedEntry[]) => Promise<void>;

package/lib/console/backendApplied.js

@@ -0,0 +1,81 @@
+import { asArray, asMap, asString, asTimestamp, getDocument, patchFields } from './firestoreRest.js';
+import { CLI_VERSION } from '../shared/paths.js';
+/**
+ * O que o PROJETO tem aplicado, devolvido ao banco onde a aplicação pode ler.
+ *
+ * O carimbo mora em cada cópia instalada (`backendState`), e o `provision` o grava nas cópias que
+ * existem no momento em que roda. A cópia que chega DEPOIS — o segundo escritório que atualiza para a
+ * versão que o primeiro já pôs no ar — ficava "Backend pendente" até alguém rodar o comando de novo, e o
+ * comando não decidia nada: a aprovação por hash já é do projeto e as functions já estavam no ar. Ele
+ * só copiava um registro.
+ *
+ * Este documento é esse registro, uma vez por projeto: para cada extensão, o fingerprint que o projeto
+ * roda. A tela libera a cópia cujo fingerprint está aqui. Quem afirma continua sendo só o Console — a
+ * regra de `backend_state` nega escrita ao cliente.
+ */
+export const BACKEND_APPLIED_PATH = '/backend_state/applied';
+/**
+ * Os campos do documento, montados sem tocar na rede.
+ *
+ * Lista e não mapa por `pluginId` porque o id tem pontos, e ponto em chave de mapa vira caminho de
+ * campo no Firestore. A FORMA é contrato com o kernel, versionado à parte — é o que o teste confere.
+ */
+export const backendAppliedFields = (entries, writtenAt) => ({
+    writtenAt: asTimestamp(writtenAt),
+    consoleVersion: asString(CLI_VERSION),
+    extensions: asArray(entries.map((entry) => asMap({
+        pluginId: asString(entry.pluginId),
+        fingerprint: asString(entry.fingerprint),
+        ...(entry.approvedHash !== undefined ? { approvedHash: asString(entry.approvedHash) } : {}),
+        ...(entry.approvedBy !== undefined ? { approvedBy: asString(entry.approvedBy) } : {}),
+    }))),
+});
+/**
+ * O documento lido, defensivo pelo mesmo motivo do lado do kernel: pode ter sido escrito por um Console
+ * de outra versão. Entrada sem id ou sem fingerprint não libera nada, então é descartada.
+ */
+export const parseBackendApplied = (data) => {
+    const list = data?.extensions;
+    if (!Array.isArray(list))
+        return [];
+    return list.flatMap((item) => {
+        if (typeof item !== 'object' || item === null)
+            return [];
+        const fields = item;
+        if (typeof fields.pluginId !== 'string' || fields.pluginId === '')
+            return [];
+        if (typeof fields.fingerprint !== 'string' || fields.fingerprint === '')
+            return [];
+        return [{
+                pluginId: fields.pluginId,
+                fingerprint: fields.fingerprint,
+                ...(typeof fields.approvedHash === 'string' ? { approvedHash: fields.approvedHash } : {}),
+                ...(typeof fields.approvedBy === 'string' ? { approvedBy: fields.approvedBy } : {}),
+            }];
+    });
+};
+export const appliedEntryOf = (entries, claim) => entries.find((entry) => entry.pluginId === claim.pluginId && entry.fingerprint === claim.fingerprint);
+/**
+ * O que continua verdadeiro aconteça o que acontecer nesta execução.
+ *
+ * Só fica a entrada de extensão ainda instalada E com o fingerprint da cópia mais nova — a que o
+ * deploy vai pôr no ar. A extensão que saiu de todo escritório pode ter a function apagada pelo
+ * `--prune`; a versão superada pode ter o código trocado pelo deploy. Nos dois casos a entrada
+ * anunciaria no ar o que talvez não esteja, e uma cópia nova nasceria liberada contra uma function que
+ * não existe — o defeito que parece CORS e que a pendência existe para impedir.
+ *
+ * Só REMOVE: acrescentar é do fim da execução, quando o deploy já respondeu.
+ */
+export const reduceBackendApplied = (entries, newest) => {
+    const standing = new Map(newest.map((claim) => [claim.pluginId, claim.fingerprint]));
+    return entries.filter((entry) => standing.get(entry.pluginId) === entry.fingerprint);
+};
+/**
+ * `[]` quando o documento não existe. Leitura recusada também vira `[]`, com aviso de quem chama: o
+ * que se perde é só o atalho — sem entradas, nada é materializado, e a redução grava a lista vazia,
+ * que é a resposta segura para "não sei o que o projeto tem".
+ */
+export const readBackendApplied = async (projectId) => parseBackendApplied(await getDocument(projectId, BACKEND_APPLIED_PATH));
+export const writeBackendApplied = async (projectId, entries) => {
+    await patchFields(projectId, BACKEND_APPLIED_PATH, backendAppliedFields(entries, new Date()));
+};

package/lib/console/exportCatalog.d.ts

@@ -1,228 +1,57 @@
 import type { ParsedArgs } from '../shared/args.js';
-import type { InstalledExtensionRecord, TenantSummary } from './installedExtensions.js';
-/**
- * `microteia export-catalog` — o RETRATO do domínio instalado, para o diretório de autoria.
- *
- * O servidor MCP do SDK monta o catálogo a partir dos `plugin.ts` do diretório mais o registro de
- * entidades do kernel. Numa instalação real isso deixa de fora as duas coisas que mais importam: a
- * tela que o escritório criou no Form Design e a extensão de terceiro já instalada. O detector de
- * "campo que pertence a outra entidade conhecida" não podia disparar contra elas, porque para ele elas
- * não existiam.
- *
- * A saída NÃO foi ligar o SDK ao Firestore. `microteia-plugin` é offline por desenho, e arrastar
- * credencial para dentro da ferramenta de autoria trocaria uma cegueira por um problema pior. Quem já
- * fala com o projeto do escritório é o Console — o token vem do `gcloud`, a cada execução, e nada é
- * guardado. Então é o Console que lê e escreve o arquivo, e o SDK apenas o encontra ali.
- *
- * Três decisões que não são preferência:
- *
- * - **O arquivo NÃO mora em `.microteia/`.** Aquele diretório é apagado por inteiro a cada `unpack`,
- *   e um retrato que some na troca de kernel é um retrato que ninguém pode depender de ter. Ele fica
- *   em `extensions/`, ao lado do `microteia.yaml`, que é onde o autor trabalha.
- * - **Ele é gitignorado**, pela conciliação que o SDK já faz do `.gitignore` daquele diretório. Ele
- *   carrega nome de tela e de campo que o escritório digitou: dado do tenant, não artefato do produto.
- * - **`--tenant` é obrigatório.** Um projeto Firebase pode ter vários escritórios, e escolher um por
- *   adivinhação escreveria o vocabulário de um dentro do trabalho de outro. Sem a opção, o comando
- *   LISTA os que existem.
- */
-/** O nome é contrato com o SDK, que o procura por este nome — ver `installedCatalog.ts` do kernel. */
-export declare const CATALOG_FILE = "installed-catalog.json";
-/**
- * A versão do FORMATO. Ela existe para que um Console de outra época não seja lido como se falasse a
- * mesma língua: o SDK recusa o que não for exatamente esta, e diz o comando que refaz o arquivo.
- */
-export declare const CATALOG_FORMAT_VERSION = 1;
-/**
- * O que viaja de cada campo, e nada além.
- *
- * A linha é ESQUEMA versus CONTEÚDO. Nome, tipo, obrigatoriedade, referência, agregado e expressão
- * descrevem o que a entidade É, e é disso que o catálogo e os detectores precisam. Opção de lista,
- * máscara, texto de ajuda, valor padrão e regra de formulário são conteúdo e apresentação: o catálogo
- * nunca os lê, e cada um deles é mais vocabulário do escritório saindo do banco sem precisar.
- */
-export interface CatalogFieldExport {
-    key: string;
-    label: string;
-    type: string;
-    required: boolean;
-    order: number;
-    multi?: boolean;
-    refEntity?: string;
-    refDenormKey?: string;
-    lookupCollection?: string;
-    section?: string;
-    origin: string;
-    ownerPluginId?: string;
-    aggregation?: Record<string, unknown>;
-    compute?: string;
-    /** O atalho de chave de um campo só — o kernel o desaçucara em `field:<key>`. */
-    unique?: true;
-}
-/**
- * Uma chave da coleção (`ScreenDefinition.keys`): o que não pode se repetir. É esquema, como o campo:
- * quem modela precisa saber que ela existe antes de propor outra, e o plano a propunha como nova a
- * cada execução quando ela só existia na instalação.
- *
- * A mensagem do conflito NÃO viaja — é apresentação, e não muda qual reserva um registro recebe. O
- * `status` também não: ele é ignorado pelo kernel desde que a adoção passou a ser estado dele.
- */
-export interface CatalogKeyExport {
-    name: string;
-    kind: string;
-    fields: string[];
-    scope?: string;
-    normalize?: {
-        trim?: boolean;
-        caseInsensitive?: boolean;
-        formatPreset?: string;
-    };
-    sparse?: boolean;
-    ownerPluginId?: string;
-}
-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;
-    titleFieldKey: string;
-    origin: string;
-    ownerPluginId?: string;
-    parentEntity?: string;
-    parentFieldKey?: string;
-    parentRelation?: string;
-    tagCollection?: string;
-    eventPrefix?: string;
-    /**
-     * Sempre escrita, mesmo vazia, pela mesma razão de `CatalogExtensionExport.exports`: a lista vazia diz
-     * "esta tela não tem chave"; a chave ausente é o silêncio de um Console anterior a este campo.
-     */
-    keys: CatalogKeyExport[];
-    fields: CatalogFieldExport[];
-}
-export interface CatalogListExport {
-    collection: string;
-    label: string;
-    ownerPluginId?: string;
-}
-/**
- * Um artefato que a extensão declara em `manifest.exports` — a superfície que outra extensão pode
- * referenciar como `<pluginId>/<sourceId>`.
- *
- * O `kind` viaja porque é ele que decide ONDE a referência cabe: script em `scriptId`, automação em
- * `targetWorkflowId`. `unknown` é o export declarado que não casa com artefato nenhum do pacote —
- * dizê-lo é melhor que omiti-lo, porque uma referência a ele passaria no portão da instalação, que
- * confere a LISTA, e falharia só na primeira execução.
- *
- * O que NÃO viaja é o que o artefato faz: os passos e o código são comportamento, e o retrato é
- * esquema. O nome e o tipo são contrato.
- */
-export interface CatalogExtensionExportedArtifact {
+import type { TenantSummary } from './installedExtensions.js';
+/** Um documento já decodificado, com o id que a coleção lhe deu — a entrada que o escritor do SDK pede. */
+export interface CatalogSourceDocument {
     id: string;
-    kind: 'workflow' | 'action' | 'script' | 'unknown';
-    name: string;
-}
-/**
- * Um grupo da barra lateral que a extensão declara (`ui.nav.group`). Viaja porque a CHAVE é contrato:
- * é o que outra extensão escreve para entrar no grupo, e quem autora sem enxergá-la inventa outra — e
- * o menu passa a mostrar dois grupos com o mesmo nome.
- *
- * O nome vai resolvido em cada idioma que o próprio pacote traz, porque é pelo nome que o autor
- * reconhece o grupo; o rótulo literal vai como está, com `translations` vazio.
- */
-export interface CatalogExtensionNavGroup {
-    key: string;
-    label: string;
-    translations: Record<string, string>;
-    order: number;
-}
-/**
- * Um modelo de documento que a extensão declara (`document.template`), como CONTRATO: a chave, a origem
- * e a forma de cada parâmetro. Viaja porque outra extensão GERA esse modelo pelo passo
- * `render-document`, com `param.<chave>` e `belongsTo`, e um nome trocado ali só aparece na geração —
- * com o campo em branco, ou com a recusa no clique.
- *
- * O que NÃO viaja é o texto do modelo, o rótulo, a regra e a amostra: é conteúdo, e o passo não os lê.
- */
-export interface CatalogExtensionDocumentParameter {
-    key: string;
-    type: string;
-    required?: boolean;
-    list?: boolean;
-    entityType?: string;
-}
-export interface CatalogExtensionDocumentTemplate {
-    key: string;
-    source: 'record' | 'payload';
-    parameters: CatalogExtensionDocumentParameter[];
+    data: Record<string, unknown>;
 }
 /**
- * Um preset de campo que a extensão declara (`data.field.preset`), como as PARTES que ele tem — nunca o
- * template, o formato nem a regra. É contra ele que o `mask` de um campo de outra extensão é conferido:
- * `mask: 'cpf-cnpj'` contra o `cpfCnpj` da Brasil instalava, e o campo ficava sem máscara.
+ * O pedaço do retrato que o Console ainda lê, para o resumo no terminal. A forma inteira é do SDK — o
+ * Console não a conhece, e é exatamente isso que o impede de escrever um formato que o kernel não lê.
  */
-export interface CatalogExtensionFieldPreset {
-    key: string;
-    slots: ('mask' | 'format' | 'validate')[];
+interface WrittenCatalog {
+    screens: {
+        origin: string;
+    }[];
+    lookups: unknown[];
+    tagLists: unknown[];
+    extensions: {
+        exports: unknown[];
+        navGroups: unknown[];
+        documentTemplates: unknown[];
+    }[];
 }
-export interface CatalogExtensionExport {
-    id: string;
-    name: string;
-    version: string;
-    active: boolean;
-    /**
-     * Sempre escrita, mesmo vazia. É a lista PRESENTE e vazia que diz "esta extensão não exporta nada";
-     * a chave ausente é o silêncio de um Console anterior a este campo, e o kernel distingue as duas.
-     */
-    exports: CatalogExtensionExportedArtifact[];
-    /** Sempre escrita, mesmo vazia, pela mesma razão de `exports`. */
-    navGroups: CatalogExtensionNavGroup[];
-    /** Sempre escrita, mesmo vazia, pela mesma razão de `exports`. */
-    documentTemplates: CatalogExtensionDocumentTemplate[];
-    /** Sempre escrita, mesmo vazia, pela mesma razão de `exports`. */
-    fieldPresets: CatalogExtensionFieldPreset[];
-}
-export interface CatalogExport {
-    version: number;
-    projectId: string;
-    tenantId: string;
-    tenantName: string;
-    exportedAt: string;
-    kernelVersion: string;
-    consoleVersion: string;
-    extensions: CatalogExtensionExport[];
-    screens: CatalogScreenExport[];
-    lookups: CatalogListExport[];
-    tagLists: CatalogListExport[];
-}
-/** Um documento já decodificado, com o id que a coleção lhe deu. */
-export interface CatalogSourceDocument {
-    id: string;
-    data: Record<string, unknown>;
-}
-export interface CatalogExportInput {
+interface CatalogWriterInput {
     projectId: string;
     tenant: TenantSummary;
     kernelVersion: string;
     exportedAt: Date;
+    exporter: {
+        tool: 'console';
+        version: string;
+    };
     screens: CatalogSourceDocument[];
     lookups: CatalogSourceDocument[];
     tagLists: CatalogSourceDocument[];
-    extensions: InstalledExtensionRecord[];
+    extensions: CatalogSourceDocument[];
+}
+/** O que o Console usa do barril do `@microteia/sdk` instalado em `extensions/`. */
+export interface CatalogWriter {
+    file: string;
+    build: (input: CatalogWriterInput) => WrittenCatalog;
+    serialize: (snapshot: WrittenCatalog) => string;
 }
 /**
- * O documento, montado a partir do que foi lido. É PURA de propósito: o que ela produz é o contrato com
- * o SDK, e um contrato que só pode ser exercitado com um projeto Firebase na frente é um contrato que
- * ninguém confere.
+ * O escritor do retrato, carregado do SDK que o escritório tem em `extensions/`.
+ *
+ * O Console trazia uma CÓPIA do escritor, e o leitor morava no SDK: os dois lados eram compilados
+ * separadamente e casados só por teste, e o Console é distribuído à parte do kernel. Carregar o
+ * escritor de onde mora o leitor faz o formato ter um dono só — e é a mesma função que a aplicação usa
+ * no botão Exportar catálogo da tela de Extensões.
  *
- * Uma tela DESLIGADA (`enabled: false`) fica de fora: a coleção dela pode até existir no banco, mas
- * nada da plataforma a desenha, e trazê-la faria o catálogo afirmar que a entidade existe. Uma tela de
- * extensão DESATIVADA continua: o documento dela segue gravado, e é ele que explica um campo que o
- * autor vai encontrar.
+ * O SDK de um kernel anterior a esse escritor não o tem, e aí o comando RECUSA dizendo como trazê-lo,
+ * em vez de escrever com uma cópia que já não é conferida contra nada.
  */
-export declare const buildCatalogExport: (input: CatalogExportInput) => CatalogExport;
+export declare const loadCatalogWriter: (directory: string) => CatalogWriter;
 export declare const exportCatalog: (args: ParsedArgs) => Promise<void>;
+export {};