@microteia/console 2.8.0 → 2.10.0

package/CONSOLE-VERSIONS.md

@@ -22,6 +22,54 @@
 - fix(command): what was broken, and what it did to whoever hit it.
 -->
 
+#### [2.10.0] — 2026-08-27
+
+- feat(export-catalog): a new command writes what an office HAS — its screens with their fields, its
+  lists of options, its tag lists and its installed extensions — into `extensions/installed-catalog.json`,
+  for the authoring tools to read. The MCP server's catalog knew only the `plugin.ts` files in that
+  directory plus the platform's own entities, so a screen built in the Form Design and an extension
+  already installed were invisible to it, and the check that catches a field belonging to another
+  entity could not fire against the entities that matter most. Closing it by giving the SDK a
+  credential was the wrong trade: `microteia-plugin` is offline by design. The Console already holds
+  the gcloud token, so the Console exports and the SDK only reads a file.
+- feat(export-catalog): `--tenant` is required, and without it the command LISTS the offices in the
+  project instead of guessing one. A Firebase project can hold several, and exporting the wrong one
+  would put another office's vocabulary inside somebody's extension work.
+- feat(export-catalog): the file is written beside `microteia.yaml`, in `extensions/` — never in
+  `.microteia/`, which `unpack` deletes whole on every kernel change. A snapshot that disappears on
+  upgrade is a snapshot nothing can depend on. `--output` overrides the path; without `extensions/`
+  the command refuses and names `microteia plugin-init`.
+- feat(export-catalog): it exports SHAPE, not content. Records, the values inside a list of options or
+  a tag list, members, permissions, workflows, scripts, actions, secrets and settings never leave the
+  office. A disabled screen is left out too: nothing draws it, and carrying it would assert that the
+  entity exists.
+- refactor(provision): reading what an office installed moved to `installedExtensions.ts`, and
+  `provision` now goes through it. Two paths to the same document are two chances to disagree about
+  what counts as installed.
+
+#### [2.9.0] — 2026-08-26
+
+- feat(deploy): `login.extensions` in `microteia.yaml` lists compiled extension packages that `deploy`
+  stamps into `hosting/microteia-extensions.js`, loaded before the bundle like `firebase-config.js`.
+  It is how a corporate SSO reaches the sign-in screen: that screen runs above the organization, so
+  nothing an organization installed can reach it, and until now the only way in was a commit in the
+  kernel.
+- feat(deploy): the stamp is written on EVERY deploy, empty list included. Skipping the write would
+  leave the previous deploy's stamp live, so removing a package from the list would not remove it from
+  the screen.
+- feat(deploy): a package that contributes to none of the points that work before sign-in is REFUSED,
+  not stamped. It would load with no effect, and whoever stamped it would believe it was live. The list
+  of those points comes from `preLoginPoints` in the installed package's manifest, never from a copy
+  here: the Console is versioned separately, and a copy would silently describe another version's
+  contract.
+- feat(deploy): the stamp is capped — a warning past 256 KiB, a refusal past 1 MiB. The file blocks the
+  page on every visit, including visits by people who never sign in.
+- feat(deploy): a duplicated package id is refused. The Kernel would ignore the second one, so the file
+  would say something the installation does not do. A missing path, broken JSON and a file that is not a
+  package each name themselves.
+- feat(deploy): a stamped package that ships views gets a warning saying its code does not run before
+  sign-in — stamping is not trusting, and that is what allows stamping without a code review.
+
 #### [2.8.0] — 2026-08-25
 
 - feat(console/functionsUpToDate): new module. It reconstructs the skip that `firebase deploy` performs in bulk and that `--only functions:<name>` disables, WITHOUT reimplementing the hash: functions are grouped by the `firebase-functions-hash` label they carry, one member of each group is deployed, and the stamp it comes back with is the stamp of the current code. The probe being a MEMBER of its group is what makes the conclusion carry to the others — two functions with the same old stamp share source, environment and secret set, the three parcels of the hash. Absent, non-`ACTIVE`, unstamped or wrong-region always deploys: not knowing never becomes skipping.

package/README.md

@@ -1,4 +1,4 @@
-# Microteia Console 2.8.0
+# Microteia Console 2.10.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/deploy.js

@@ -15,6 +15,7 @@ import { installPath, readInstalledManifest } from './unpack.js';
 import { ensureOfficeEnv, ensureRootGitignore, officeEnvName, stageOfficeEnv } from './backendEnv.js';
 import { gatherCustomFunctions, readOfficeFunctions } from './customFunctions.js';
 import { readResolvedConfig, stampedConfigJs, writeResolvedConfig, } from './workspace.js';
+import { STAMP_FILE, buildLoginExtensions, stampPath } from './loginExtensions.js';
 const COMPONENTS = ['rules', 'indexes', 'functions', 'hosting'];
 const selectedComponents = (args) => {
     const only = flagValue(args, 'only');
@@ -63,6 +64,20 @@ export const deploy = async (args) => {
     await writeResolvedConfig(root, stamped);
     await writeFile(join(install, 'hosting', 'firebase-config.js'), stampedConfigJs(stamped));
     success(`hosting/firebase-config.js → ${projectId}`);
+    // As extensões que valem ANTES do login. Carimbadas no mesmo passo da configuração porque são a
+    // mesma coisa: o que o navegador precisa saber antes de o bundle subir. Escrito sempre, mesmo vazio
+    // — pular a escrita deixaria o carimbo do deploy anterior no ar, e tirar um pacote da lista não o
+    // tiraria da tela.
+    const loginExtensions = await buildLoginExtensions(root, environment.login.extensions, manifest.preLoginPoints);
+    await writeFile(stampPath(install), loginExtensions.contents);
+    if (loginExtensions.stamped.length === 0) {
+        success(`hosting/${STAMP_FILE} → no extensions before sign-in`);
+    }
+    else {
+        success(`hosting/${STAMP_FILE} → ${loginExtensions.stamped.join(', ')}`);
+    }
+    for (const warning of loginExtensions.warnings)
+        warn(warning);
     // O arquivo que o escritório edita é o da RAIZ; o que o `firebase-functions` lê tem de estar em
     // `install/functions/`, e por isso é uma cópia escrita agora. Antes a fonte era a cópia, e o deploy
     // seguinte a apagava junto com o pacote.

package/lib/console/environment.d.ts

@@ -53,6 +53,21 @@ export interface Environment {
          */
         indexes: string | null;
     };
+    /**
+     * As extensões que a instalação carrega ANTES do login — os pacotes compilados que `deploy` carimba
+     * em `microteia-extensions.js`. É por aqui que um SSO chega à tela de entrada: ali não há escritório,
+     * logo não há como ler o que um escritório instalou.
+     *
+     * É uma lista de CAMINHOS, e é deliberado que seja explícita. Varrer `extensions/` poria no ar um
+     * rascunho de autoria — aquele diretório é onde se escreve, não o que roda. Carimbar é um ato, e
+     * escrever o caminho aqui é o ato.
+     *
+     * Escalar separado por vírgula, como `backend.functions`, pela mesma razão: o leitor de YAML daqui
+     * entende mapas de dois níveis e escalares.
+     */
+    login: {
+        extensions: string | null;
+    };
 }
 export declare const ENVIRONMENT_FILE = "microteia.yaml";
 export declare const parseEnvironment: (source: string) => Environment;

package/lib/console/environment.js

@@ -83,6 +83,7 @@ export const parseEnvironment = (source) => {
             parameters: optional('backend', 'parameters'),
             indexes: optional('backend', 'indexes'),
         },
+        login: { extensions: optional('login', 'extensions') },
     };
 };
 export const serializeEnvironment = (environment) => `# Microteia installation.
@@ -128,6 +129,16 @@ backend:
   # "firebase deploy" offer to delete the indexes of every extension. Managed by
   # "microteia provision".
   indexes: ${quote(environment.backend.indexes)}
+
+login:
+  # Compiled extension packages (.json) to load BEFORE anyone signs in — this is how a corporate SSO
+  # reaches the sign-in screen, since there is no organization to read it from yet. Comma-separated
+  # paths, relative to this file. "microteia deploy" stamps them into microteia-extensions.js and
+  # refuses a package that contributes to none of the points that work before sign-in.
+  #
+  # Nothing stamped here runs JavaScript: the packages load as untrusted, so only declarations apply.
+  # To USE an extension inside the organization, install it from the Extensions screen instead.
+  extensions: ${quote(environment.login.extensions)}
 `;
 export const readEnvironment = async (path) => {
     try {

package/lib/console/exportCatalog.d.ts

@@ -0,0 +1,124 @@
+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;
+}
+export interface CatalogScreenExport {
+    key: string;
+    collection?: string;
+    titleSingular: string;
+    titlePlural?: string;
+    titleFieldKey: string;
+    origin: string;
+    ownerPluginId?: string;
+    parentEntity?: string;
+    parentFieldKey?: string;
+    parentRelation?: string;
+    tagCollection?: string;
+    eventPrefix?: string;
+    fields: CatalogFieldExport[];
+}
+export interface CatalogListExport {
+    collection: string;
+    label: string;
+    ownerPluginId?: string;
+}
+export interface CatalogExtensionExport {
+    id: string;
+    name: string;
+    version: string;
+    active: boolean;
+}
+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 {
+    projectId: string;
+    tenant: TenantSummary;
+    kernelVersion: string;
+    exportedAt: Date;
+    screens: CatalogSourceDocument[];
+    lookups: CatalogSourceDocument[];
+    tagLists: CatalogSourceDocument[];
+    extensions: InstalledExtensionRecord[];
+}
+/**
+ * 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.
+ *
+ * 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.
+ */
+export declare const buildCatalogExport: (input: CatalogExportInput) => CatalogExport;
+export declare const exportCatalog: (args: ParsedArgs) => Promise<void>;

package/lib/console/exportCatalog.js

@@ -0,0 +1,264 @@
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join, relative, resolve } from 'node:path';
+import { flagValue } from '../shared/args.js';
+import { CLI_VERSION } from '../shared/paths.js';
+import { blank, bullets, heading, info, step, success, warn } from '../shared/ui.js';
+import { decodeFields, documentId, listDocuments } from './firestoreRest.js';
+import { listTenants, readInstalledExtensions } from './installedExtensions.js';
+import { ENVIRONMENT_FILE, readEnvironment } from './environment.js';
+import { EXTENSIONS_DIR } from './pluginWorkspace.js';
+import { WORKSPACE_DIR } from './workspace.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 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 const CATALOG_FORMAT_VERSION = 1;
+const text = (value) => (typeof value === 'string' && value.trim() !== '' ? value : undefined);
+const asRecord = (value) => (typeof value === 'object' && value !== null && !Array.isArray(value)
+    ? value
+    : undefined);
+const FIELD_ORIGINS = ['builtin', 'plugin', 'design'];
+/**
+ * A mesma dedução que a aplicação faz ao ler a tela (`screenDefinitionMapper.ts`): o `origin` gravado
+ * quando ele existe, senão `plugin` para quem tem dono e `design` para o que o escritório criou. Ela é
+ * repetida aqui porque o Console não alcança `src/` — e é conferida contra a instalação real por teste.
+ */
+const originOf = (data, fallback) => {
+    const declared = text(data.origin);
+    if (declared !== undefined && FIELD_ORIGINS.includes(declared))
+        return declared;
+    return text(data.ownerPluginId) !== undefined ? 'plugin' : fallback;
+};
+const fieldExport = (raw, index, screenOrigin) => {
+    const field = asRecord(raw);
+    if (field === undefined)
+        return null;
+    const key = text(field.key);
+    if (key === undefined)
+        return null;
+    const logic = asRecord(field.logic);
+    const compute = text(logic?.compute);
+    return {
+        key,
+        label: text(field.label) ?? key,
+        type: text(field.type) ?? 'text',
+        required: field.required === true,
+        order: typeof field.order === 'number' ? field.order : index,
+        ...(field.multi === true ? { multi: true } : {}),
+        ...(text(field.refEntity) === undefined ? {} : { refEntity: text(field.refEntity) }),
+        ...(text(field.refDenormKey) === undefined ? {} : { refDenormKey: text(field.refDenormKey) }),
+        ...(text(field.lookupCollection) === undefined ? {} : { lookupCollection: text(field.lookupCollection) }),
+        ...(text(field.section) === undefined ? {} : { section: text(field.section) }),
+        origin: originOf(field, screenOrigin),
+        ...(text(field.ownerPluginId) === undefined ? {} : { ownerPluginId: text(field.ownerPluginId) }),
+        ...(asRecord(field.aggregation) === undefined ? {} : { aggregation: asRecord(field.aggregation) }),
+        ...(compute === undefined ? {} : { compute }),
+    };
+};
+const screenExport = (document) => {
+    const data = document.data;
+    const origin = originOf(data, 'design');
+    const fields = Array.isArray(data.fields) ? data.fields : [];
+    return {
+        key: document.id,
+        ...(text(data.dataCollection) === undefined ? {} : { collection: text(data.dataCollection) }),
+        titleSingular: text(data.titleSingular) ?? document.id,
+        ...(text(data.titlePlural) === undefined ? {} : { titlePlural: text(data.titlePlural) }),
+        titleFieldKey: text(data.titleFieldKey) ?? '',
+        origin,
+        ...(text(data.ownerPluginId) === undefined ? {} : { ownerPluginId: text(data.ownerPluginId) }),
+        ...(text(data.parentEntity) === undefined ? {} : { parentEntity: text(data.parentEntity) }),
+        ...(text(data.parentFieldKey) === undefined ? {} : { parentFieldKey: text(data.parentFieldKey) }),
+        ...(text(data.parentRelation) === undefined ? {} : { parentRelation: text(data.parentRelation) }),
+        ...(text(data.tagCollection) === undefined ? {} : { tagCollection: text(data.tagCollection) }),
+        ...(text(data.eventPrefix) === undefined ? {} : { eventPrefix: text(data.eventPrefix) }),
+        fields: fields
+            .map((field, index) => fieldExport(field, index, origin))
+            .filter((field) => field !== null),
+    };
+};
+/**
+ * O id do documento É o nome da coleção da lista, tanto em `lookupDefinitions` quanto em
+ * `tagDefinitions` — a mesma convenção que os repositórios da aplicação usam ao mapeá-las.
+ */
+const listExport = (document) => ({
+    collection: document.id,
+    label: text(document.data.label) ?? document.id,
+    ...(text(document.data.ownerPluginId) === undefined
+        ? {}
+        : { ownerPluginId: text(document.data.ownerPluginId) }),
+});
+/**
+ * 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.
+ *
+ * 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.
+ */
+export const buildCatalogExport = (input) => ({
+    version: CATALOG_FORMAT_VERSION,
+    projectId: input.projectId,
+    tenantId: input.tenant.id,
+    tenantName: input.tenant.name,
+    exportedAt: input.exportedAt.toISOString(),
+    kernelVersion: input.kernelVersion,
+    consoleVersion: CLI_VERSION,
+    extensions: input.extensions
+        .map((one) => ({ id: one.id, name: one.name, version: one.version, active: one.active }))
+        .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)),
+    screens: input.screens
+        .filter((document) => document.data.enabled !== false)
+        .map(screenExport)
+        .sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0)),
+    lookups: input.lookups
+        .map(listExport)
+        .sort((a, b) => (a.collection < b.collection ? -1 : a.collection > b.collection ? 1 : 0)),
+    tagLists: input.tagLists
+        .map(listExport)
+        .sort((a, b) => (a.collection < b.collection ? -1 : a.collection > b.collection ? 1 : 0)),
+});
+const decode = (documents) => documents.map((document) => ({ id: documentId(document), data: decodeFields(document.fields) }));
+const readSubcollection = async (projectId, tenantId, name) => decode(await listDocuments(projectId, `/tenants/${tenantId}/${name}`));
+/**
+ * O kernel que está NO LUGAR nesta instalação, e não o que já foi publicado: o retrato descreve o
+ * contrato contra o qual o autor compila agora. Ausente, o SDK dirá que não sabe — o que é melhor que
+ * carimbar uma versão inventada.
+ */
+const installedKernelVersion = async (root) => {
+    const path = join(root, WORKSPACE_DIR, 'install', 'manifest.json');
+    if (!existsSync(path))
+        return 'unknown';
+    try {
+        const manifest = JSON.parse(await readFile(path, 'utf8'));
+        return typeof manifest.kernelVersion === 'string' ? manifest.kernelVersion : 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+};
+/**
+ * O arquivo é gitignorado pela conciliação que o SDK faz do `.gitignore` de `extensions/` — este
+ * comando não escreve naquele arquivo, porque a política é de lá. O que ele faz é OLHAR: se a linha
+ * ainda não chegou (um diretório sincronizado por um kernel anterior), diz qual comando a traz, em vez
+ * de deixar o retrato pronto para ser commitado sem ninguém notar.
+ */
+const checkIgnored = async (directory) => {
+    const path = join(directory, '.gitignore');
+    if (!existsSync(path))
+        return;
+    const lines = (await readFile(path, 'utf8')).split('\n').map((line) => line.trim());
+    if (lines.includes(CATALOG_FILE) || lines.includes('*.json'))
+        return;
+    warn(`${relative(process.cwd(), path) || '.gitignore'} does not ignore ${CATALOG_FILE}.`);
+    info('  It carries screen and field names the office typed, which is tenant data and does not belong');
+    info(`  in an extension repository. Run "npm run sync" in ${EXTENSIONS_DIR}/ to get the line, or add it`);
+    info('  by hand.');
+};
+const listAndStop = (tenants, projectId) => {
+    if (tenants.length === 0) {
+        warn(`${projectId} has no office yet, so there is no catalog to export.`);
+        info('  An office is created the first time somebody signs in to the application.');
+        blank();
+        return;
+    }
+    info(`${projectId} has ${tenants.length} office(s). Pick one:`);
+    bullets(tenants.map((tenant) => `${tenant.name} — microteia export-catalog --tenant ${tenant.id}`));
+    blank();
+    info('The export is per office because screens, lists and tag lists are per office: exporting the');
+    info('wrong one would put another office\'s vocabulary inside your extension work.');
+    blank();
+};
+export const exportCatalog = async (args) => {
+    const file = resolve(flagValue(args, 'file') ?? join(process.cwd(), ENVIRONMENT_FILE));
+    const root = dirname(file);
+    const environment = await readEnvironment(file);
+    const projectId = environment.firebase.projectId;
+    if (projectId === null) {
+        throw new Error('This installation is not connected yet. Run "microteia connect --project <id>".');
+    }
+    heading(`Exporting the installed catalog from ${projectId}`);
+    const tenants = await listTenants(projectId);
+    const wanted = flagValue(args, 'tenant');
+    if (wanted === undefined) {
+        listAndStop(tenants, projectId);
+        return;
+    }
+    const tenant = tenants.find((one) => one.id === wanted);
+    if (tenant === undefined) {
+        throw new Error(`${projectId} has no office with id "${wanted}".\n`
+            + `  Offices in this project: ${tenants.length === 0 ? '(none)' : tenants.map((one) => `${one.name} (${one.id})`).join(', ')}`);
+    }
+    const output = flagValue(args, 'output');
+    const directory = join(root, EXTENSIONS_DIR);
+    if (output === undefined && !existsSync(directory)) {
+        throw new Error(`There is no ${EXTENSIONS_DIR}/ in this installation, and that is where the catalog belongs — it\n`
+            + '  exists to answer the authoring tools, and nothing else reads it.\n'
+            + '  Run "microteia plugin-init" first, or pass --output <path> to put it somewhere else.');
+    }
+    const target = output === undefined ? join(directory, CATALOG_FILE) : resolve(output);
+    step(1, 2, `Reading what ${tenant.name} has`);
+    const [screens, lookups, tagLists, extensions] = await Promise.all([
+        readSubcollection(projectId, tenant.id, 'screenDefinitions'),
+        readSubcollection(projectId, tenant.id, 'lookupDefinitions'),
+        readSubcollection(projectId, tenant.id, 'tagDefinitions'),
+        readInstalledExtensions(projectId, tenant.id),
+    ]);
+    const document = buildCatalogExport({
+        projectId,
+        tenant,
+        kernelVersion: await installedKernelVersion(root),
+        exportedAt: new Date(),
+        screens,
+        lookups,
+        tagLists,
+        extensions,
+    });
+    step(2, 2, 'Writing the snapshot');
+    await mkdir(dirname(target), { recursive: true });
+    await writeFile(target, `${JSON.stringify(document, null, 2)}\n`);
+    const fromExtensions = document.screens.filter((screen) => screen.origin === 'plugin').length;
+    success(`${relative(process.cwd(), target) || CATALOG_FILE} — ${document.screens.length} screen(s), `
+        + `${document.lookups.length} list(s), ${document.tagLists.length} tag list(s)`);
+    info(`  ${fromExtensions} screen(s) come from the ${document.extensions.length} installed extension(s); `
+        + `the rest the office built itself.`);
+    blank();
+    await checkIgnored(directory);
+    info('It is a SNAPSHOT, and it says so: the authoring tools report when it was taken and warn when it');
+    info('is old. Nothing keeps it in step with the office — run this again after screens change there.');
+    blank();
+    info('What it deliberately leaves out: records, the values inside a list of options or a tag list,');
+    info('members and permissions, workflows, scripts, actions, secrets and settings. It describes what');
+    info('the entities ARE, and nothing an office typed into them.');
+    blank();
+};

package/lib/console/init.js

@@ -31,6 +31,7 @@ export const init = async (args) => {
         firebase: { projectId: null, region: DEFAULT_FUNCTIONS_REGION },
         kernel: { version: null, deployed: null },
         backend: { functions: null, parameters: null, indexes: null },
+        login: { extensions: null },
     };
     await writeEnvironment(file, environment);
     // O diretório de trabalho guarda o pacote desempacotado e a configuração resolvida. Ele é local à

package/lib/console/installedExtensions.d.ts

@@ -0,0 +1,37 @@
+/**
+ * O CAMINHO ÚNICO até o que um escritório instalou.
+ *
+ * Estava dentro do `provision`, e é dele que a leitura nasceu: para saber quais Cloud Functions subir,
+ * o comando precisa do `manifest.backend` de cada extensão instalada. O `export-catalog` faz a mesma
+ * pergunta com outro propósito, e um segundo caminho até o mesmo documento seria uma segunda chance de
+ * discordar — a forma do documento, o que conta como instalada, o que fazer com a desativada.
+ *
+ * Então o caminho é este, e o `provision` também passa por aqui.
+ */
+/** Um escritório do projeto. O `name` existe para que escolher um `--tenant` não seja adivinhar um id. */
+export interface TenantSummary {
+    id: string;
+    name: string;
+}
+export interface InstalledExtensionRecord {
+    tenantId: string;
+    documentPath: string;
+    id: string;
+    name: string;
+    version: string;
+    /** Desligada no escritório: o pacote continua ali, e nada dele está no ar. */
+    active: boolean;
+    /** O manifesto cru da cópia instalada — é dele que sai `backend`, e nada aqui o interpreta. */
+    manifest: Record<string, unknown> | undefined;
+    /** O documento inteiro, decodificado, para quem precisa de mais que o manifesto. */
+    data: Record<string, unknown>;
+}
+export declare const listTenants: (projectId: string) => Promise<TenantSummary[]>;
+/**
+ * As extensões instaladas num escritório.
+ *
+ * A DESATIVADA vem junto, marcada. Quem decide o que fazer com ela é quem chamou: para o `provision`
+ * ela não exige backend nenhum; para o catálogo ela ainda explica de onde veio uma tela que continua
+ * gravada no banco.
+ */
+export declare const readInstalledExtensions: (projectId: string, tenantId: string) => Promise<InstalledExtensionRecord[]>;

package/lib/console/installedExtensions.js

@@ -0,0 +1,37 @@
+import { decodeFields, documentId, listDocuments } from './firestoreRest.js';
+export const listTenants = async (projectId) => {
+    const documents = await listDocuments(projectId, '/tenants');
+    return documents
+        .map((document) => {
+        const id = documentId(document);
+        const data = decodeFields(document.fields);
+        return { id, name: typeof data.name === 'string' && data.name !== '' ? data.name : id };
+    })
+        .sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+};
+/**
+ * As extensões instaladas num escritório.
+ *
+ * A DESATIVADA vem junto, marcada. Quem decide o que fazer com ela é quem chamou: para o `provision`
+ * ela não exige backend nenhum; para o catálogo ela ainda explica de onde veio uma tela que continua
+ * gravada no banco.
+ */
+export const readInstalledExtensions = async (projectId, tenantId) => {
+    const documents = await listDocuments(projectId, `/tenants/${tenantId}/installed_extensions`);
+    return documents.map((document) => {
+        const data = decodeFields(document.fields);
+        const pkg = data.package;
+        const manifest = pkg?.manifest;
+        const fallbackId = documentId(document);
+        return {
+            tenantId,
+            documentPath: `/tenants/${tenantId}/installed_extensions/${fallbackId}`,
+            id: String(manifest?.id ?? fallbackId),
+            name: String(manifest?.name ?? manifest?.id ?? fallbackId),
+            version: String(manifest?.version ?? '0.0.0'),
+            active: data.active !== false,
+            manifest,
+            data,
+        };
+    });
+};

package/lib/console/loginExtensions.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Este arquivo BLOQUEIA a página: é um `<script>` no `<head>`, antes do bundle. Um pacote gordo aqui
+ * custa em toda visita, inclusive na de quem nem vai entrar. O aviso vem antes de doer, e a recusa
+ * vem quando já dói para todo mundo.
+ */
+export declare const STAMP_WARN_BYTES: number;
+export declare const STAMP_MAX_BYTES: number;
+export declare const STAMP_FILE = "microteia-extensions.js";
+export interface LoginExtensionsResult {
+    /** O conteúdo do arquivo carimbado. Escrito sempre, mesmo vazio — ver `stampLoginExtensions`. */
+    contents: string;
+    /** `id@version` de cada pacote carimbado, na ordem declarada. */
+    stamped: string[];
+    /** O que quem instala precisa saber sem que o deploy pare. */
+    warnings: string[];
+    bytes: number;
+}
+export declare const parseExtensionPaths: (declared: string | null) => string[];
+/**
+ * Monta o carimbo. `preLoginPoints` vem do manifesto do PACOTE do kernel instalado, e não de uma lista
+ * aqui: o Console é versionado separadamente, e uma cópia dela passaria a descrever o contrato de
+ * outra versão em silêncio. Ausente (pacote antigo), a checagem é pulada em vez de inventada.
+ */
+export declare const buildLoginExtensions: (root: string, declared: string | null, preLoginPoints: string[] | undefined) => Promise<LoginExtensionsResult>;
+/**
+ * Escreve o carimbo SEMPRE, inclusive vazio. Pular a escrita quando a lista está vazia deixaria o
+ * carimbo do deploy anterior no ar: tirar um pacote de `login.extensions` não o tiraria da tela.
+ */
+export declare const stampPath: (install: string) => string;

package/lib/console/loginExtensions.js

@@ -0,0 +1,101 @@
+import { readFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+/**
+ * Este arquivo BLOQUEIA a página: é um `<script>` no `<head>`, antes do bundle. Um pacote gordo aqui
+ * custa em toda visita, inclusive na de quem nem vai entrar. O aviso vem antes de doer, e a recusa
+ * vem quando já dói para todo mundo.
+ */
+export const STAMP_WARN_BYTES = 256 * 1024;
+export const STAMP_MAX_BYTES = 1024 * 1024;
+export const STAMP_FILE = 'microteia-extensions.js';
+export const parseExtensionPaths = (declared) => (declared ?? '')
+    .split(',')
+    .map((entry) => entry.trim())
+    .filter((entry) => entry !== '');
+const asStampedPackage = (parsed, path) => {
+    const manifest = parsed?.manifest;
+    if (!manifest || typeof manifest !== 'object') {
+        throw new Error(`${path} is not an extension package: it has no "manifest".`);
+    }
+    const { id, version, contributes } = manifest;
+    if (typeof id !== 'string' || id === '') {
+        throw new Error(`${path} has no "manifest.id".`);
+    }
+    if (typeof version !== 'string' || version === '') {
+        throw new Error(`${path} has no "manifest.version".`);
+    }
+    if (!Array.isArray(contributes)) {
+        throw new Error(`${path} has no "manifest.contributes" array.`);
+    }
+    return parsed;
+};
+/**
+ * Monta o carimbo. `preLoginPoints` vem do manifesto do PACOTE do kernel instalado, e não de uma lista
+ * aqui: o Console é versionado separadamente, e uma cópia dela passaria a descrever o contrato de
+ * outra versão em silêncio. Ausente (pacote antigo), a checagem é pulada em vez de inventada.
+ */
+export const buildLoginExtensions = async (root, declared, preLoginPoints) => {
+    const paths = parseExtensionPaths(declared);
+    const packages = [];
+    const stamped = [];
+    const warnings = [];
+    for (const path of paths) {
+        const absolute = resolve(root, path);
+        let parsed;
+        try {
+            parsed = JSON.parse(await readFile(absolute, 'utf8'));
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                throw new Error(`login.extensions lists ${path}, which does not exist.\n`
+                    + 'Compile the extension first ("microteia-plugin build" inside extensions/), '
+                    + 'or remove the path from microteia.yaml.', { cause: error });
+            }
+            throw new Error(`${path} is not valid JSON.`, { cause: error });
+        }
+        const pkg = asStampedPackage(parsed, path);
+        if (preLoginPoints !== undefined) {
+            const points = pkg.manifest.contributes
+                .map((contribution) => contribution.point)
+                .filter((point) => typeof point === 'string');
+            const effective = points.filter((point) => preLoginPoints.includes(point));
+            if (effective.length === 0) {
+                throw new Error(`${path} (${pkg.manifest.id}) contributes nothing that works before sign-in, so stamping it `
+                    + 'would load it with no effect.\n'
+                    + `  Points that work before sign-in: ${preLoginPoints.join(', ')}.\n`
+                    + `  This package contributes: ${points.length === 0 ? '(none)' : [...new Set(points)].join(', ')}.\n`
+                    + '  To USE it inside the organization, install it from the Extensions screen instead.');
+            }
+        }
+        if (Array.isArray(pkg.views) && pkg.views.length > 0) {
+            warnings.push(`${pkg.manifest.id} ships ${pkg.views.length} view(s): stamped packages load untrusted, `
+                + 'so their code does not run before sign-in — only declarations apply');
+        }
+        const duplicate = packages.find((existing) => existing.manifest.id === pkg.manifest.id);
+        if (duplicate !== undefined) {
+            throw new Error(`login.extensions lists ${pkg.manifest.id} twice. The Kernel would ignore the second one, `
+                + 'so the file says something the installation does not do.');
+        }
+        packages.push(pkg);
+        stamped.push(`${pkg.manifest.id}@${pkg.manifest.version}`);
+    }
+    const contents = `// Generated by "microteia deploy". Do not edit by hand.\n`
+        + `window.__MICROTEIA_EXTENSIONS__ = ${JSON.stringify(packages)};\n`;
+    const bytes = Buffer.byteLength(contents, 'utf8');
+    if (bytes > STAMP_MAX_BYTES) {
+        throw new Error(`The stamped extensions would be ${Math.round(bytes / 1024)} KiB, over the `
+            + `${STAMP_MAX_BYTES / 1024} KiB limit. This file blocks the page on every visit, including `
+            + 'visits by people who never sign in.\n'
+            + '  Keep before-sign-in packages to what the sign-in screen needs, and install the rest.');
+    }
+    if (bytes > STAMP_WARN_BYTES) {
+        warnings.push(`the stamped extensions are ${Math.round(bytes / 1024)} KiB, and this file blocks the page on `
+            + 'every visit');
+    }
+    return { contents, stamped, warnings, bytes };
+};
+/**
+ * Escreve o carimbo SEMPRE, inclusive vazio. Pular a escrita quando a lista está vazia deixaria o
+ * carimbo do deploy anterior no ar: tirar um pacote de `login.extensions` não o tiraria da tela.
+ */
+export const stampPath = (install) => join(install, 'hosting', STAMP_FILE);

package/lib/console/provision.js

@@ -13,7 +13,8 @@ import { deployFunctionsOneByOne, reportFailures, reportNotices } from './deploy
 import { clearRegionOrphans, listDeployedFunctions } from './regionOrphans.js';
 import { outdatedByStamp } from './functionsUpToDate.js';
 import { checkCallables, invokerGrantCommand } from './callableAccess.js';
-import { asString, asTimestamp, decodeFields, documentId, listDocuments, patchMapField } from './firestoreRest.js';
+import { asString, asTimestamp, patchMapField } from './firestoreRest.js';
+import { listTenants, readInstalledExtensions } from './installedExtensions.js';
 import { gatherCustomFunctions, readOfficeFunctions } from './customFunctions.js';
 /**
  * O que cada escritório do projeto instalou e exige do backend.
@@ -23,27 +24,22 @@ import { gatherCustomFunctions, readOfficeFunctions } from './customFunctions.js
  * explicação; não há injeção possível, porque o código é sempre o do pacote.
  */
 export const readInstalledClaims = async (projectId) => {
-    const tenants = await listDocuments(projectId, '/tenants');
+    const tenants = await listTenants(projectId);
     const claims = [];
     for (const tenant of tenants) {
-        const tenantId = documentId(tenant);
-        const extensions = await listDocuments(projectId, `/tenants/${tenantId}/installed_extensions`);
-        for (const document of extensions) {
-            const data = decodeFields(document.fields);
-            if (data.active === false)
+        for (const extension of await readInstalledExtensions(projectId, tenant.id)) {
+            if (!extension.active)
                 continue;
-            const pkg = data.package;
-            const manifest = pkg?.manifest;
-            const backend = manifest?.backend;
+            const backend = extension.manifest?.backend;
             if (!hasBackendRequirement(backend))
                 continue;
-            const state = data.backendState;
+            const state = extension.data.backendState;
             claims.push({
-                tenantId,
-                documentPath: `/tenants/${tenantId}/installed_extensions/${documentId(document)}`,
-                pluginId: String(manifest?.id ?? documentId(document)),
-                name: String(manifest?.name ?? manifest?.id ?? documentId(document)),
-                version: String(manifest?.version ?? '0.0.0'),
+                tenantId: extension.tenantId,
+                documentPath: extension.documentPath,
+                pluginId: extension.id,
+                name: extension.name,
+                version: extension.version,
                 backend: backend,
                 applied: state?.fingerprint === backendFingerprint(backend),
             });

package/lib/index.js

@@ -10,6 +10,7 @@ import { connect } from './console/connect.js';
 import { unpack } from './console/unpack.js';
 import { deploy } from './console/deploy.js';
 import { provision } from './console/provision.js';
+import { exportCatalog } from './console/exportCatalog.js';
 import { pluginInit } from './console/pluginWorkspace.js';
 import { versionReport } from './console/versions.js';
 import { newerThan } from './console/channel.js';
@@ -49,6 +50,13 @@ const COMMANDS = [
         audience: 'office',
         execute: provision,
     },
+    {
+        name: 'export-catalog',
+        usage: 'microteia export-catalog --tenant <tenantId> [--output <path>]',
+        summary: 'Write what an office has — screens, lists, extensions — for the authoring tools to read.',
+        audience: 'office',
+        execute: exportCatalog,
+    },
     {
         name: 'plugin-init',
         usage: 'microteia plugin-init [--dir <path>] [--force]',

package/lib/kernel/manifest.d.ts

@@ -44,6 +44,16 @@ export interface KernelManifest {
     baselineIndexes: FirestoreIndexSpec[];
     /** Ausente nos pacotes anteriores a 7.51.0, que não conheciam a verificação de alcance. */
     callables?: string[];
+    /**
+     * Os pontos de extensão que fazem efeito ANTES do login. É contra esta lista que o `deploy` decide
+     * se um pacote carimbado tem o que fazer no boot — carimbar um que não contribua para nenhum deles
+     * o carregaria sem efeito, e quem o carimbou acreditaria que está no ar.
+     *
+     * Ela é DERIVADA do kernel e viaja no manifesto justamente para o Console não a conhecer de cor: o
+     * Console é versionado separadamente, e uma cópia aqui passaria a descrever o contrato de outra
+     * versão em silêncio. Ausente nos pacotes anteriores às extensões carimbadas.
+     */
+    preLoginPoints?: string[];
     backendParameters: BackendParameter[];
     manualPrerequisites: KernelPrerequisite[];
     /**
@@ -135,4 +145,10 @@ export declare const callableFunctionNames: (source: string) => string[];
 export declare const declaredParametersIn: (source: string) => BackendParameter[];
 /** Comparação de versão suficiente para `minimumCliVersion`: três números, sem pré-lançamento. */
 export declare const compareVersions: (left: string, right: string) => number;
+/**
+ * Os pontos que valem antes do login, lidos de `domain/schema/plugin/preLoginPoints.ts`. Lista vazia é
+ * recusada em vez de aceita: um pacote sem nenhum ponto pré-login recusaria todo carimbo, e a causa
+ * (o parser não achou nada) não teria nada a ver com o sintoma.
+ */
+export declare const parsePreLoginPoints: (source: string) => string[];
 export declare const parseKernelVersion: (source: string) => string;

package/lib/kernel/manifest.js

@@ -137,6 +137,22 @@ export const compareVersions = (left, right) => {
     }
     return 0;
 };
+/**
+ * Os pontos que valem antes do login, lidos de `domain/schema/plugin/preLoginPoints.ts`. Lista vazia é
+ * recusada em vez de aceita: um pacote sem nenhum ponto pré-login recusaria todo carimbo, e a causa
+ * (o parser não achou nada) não teria nada a ver com o sintoma.
+ */
+export const parsePreLoginPoints = (source) => {
+    const block = source.match(/PRE_LOGIN_POINTS[^=]*=\s*\[([^\]]*)\]/);
+    if (block === null) {
+        throw new Error('PRE_LOGIN_POINTS not found in domain/schema/plugin/preLoginPoints.ts');
+    }
+    const points = [...block[1].matchAll(/'([^']+)'/g)].map((match) => match[1]);
+    if (points.length === 0) {
+        throw new Error('PRE_LOGIN_POINTS is empty in domain/schema/plugin/preLoginPoints.ts');
+    }
+    return points;
+};
 export const parseKernelVersion = (source) => {
     const match = source.match(/KERNEL_VERSION\s*=\s*'([^']+)'/);
     if (match === null)

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.8.0";
+export declare const CLI_VERSION = "2.10.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.8.0';
+export const CLI_VERSION = '2.10.0';

package/lib/vendor/exampleSources.js

@@ -31,7 +31,9 @@ export const EXAMPLE_SOURCES = {
  * extensão tem a sua pasta — aqui elas moram num diretório comum, com um nível a mais.
  */
 export const rewriteImports = (source) => source.replace(/from '(\.[^']*)'/g, (match, specifier) => {
-    if (/(^|\/)contributionBuilders$/.test(specifier) || specifier.includes('domain/')) {
+    if (/(^|\/)contributionBuilders$/.test(specifier)
+        || specifier.includes('domain/')
+        || specifier.includes('sdk/')) {
         return "from '@microteia/sdk'";
     }
     // `./views/<plugin>/Nome.tsx?raw` -> `./views/Nome.tsx?raw`
@@ -44,8 +46,10 @@ const HEADER = (id) => `// Example: a Microteia first-party extension, as SOURCE
 //
 //     npx microteia-plugin build ${id}/plugin.ts
 //
-// The only difference from how it is written inside Microteia is the import path: there it reaches into
-// the kernel tree, here everything comes from '@microteia/sdk'.
+// Two things differ from how you would write the same extension. The imports: inside Microteia they
+// reach into the kernel tree, here everything comes from '@microteia/sdk'. And the view sources: these
+// travel as TEXT and are merged by 'mergeViewSources', because the platform bundles them; you point at
+// the files with 'sourceFile' and the compiler merges them for you. See AUTHORING.md, section 7.
 
 `;
 /**

package/lib/vendor/installationDocs.js

@@ -94,6 +94,7 @@ const commandRows = () => [
     '| `microteia provision [--prune] [--all]` | Gives installed extensions the functions and indexes they ask for |',
     '| `microteia connect --project <id>` | Binds this installation to a Firebase project you own |',
     '| `microteia plugin-init` | Prepares `extensions/` for authoring in TypeScript |',
+    '| `microteia export-catalog --tenant <id>` | Writes what an office has — screens, lists, installed extensions — into `extensions/`, so the authoring tools can see it. Reads only; with no `--tenant` it lists the offices. The file is a snapshot and is git-ignored: it carries names the office typed |',
 ].join('\n');
 /**
  * O documento técnico. SOBREPOSTO a cada `unpack`, e por isso é onde o detalhe que acompanha a versão
@@ -145,6 +146,23 @@ it is what makes an upgrade trustworthy, and the reason your files are elsewhere
 
 ${commandRows()}
 
+### Signing in before there is an organization
+
+The sign-in screen runs above the organization: there is no tenant there, so nothing an organization
+installed can reach it. That is why \`login.extensions\` in \`microteia.yaml\` exists — it lists compiled
+extension packages that \`deploy\` stamps into the site itself, and it is how a corporate SSO, or your own
+mark on the sign-in screen, gets there.
+
+Two things follow, and both are deliberate:
+
+- **Nothing stamped runs JavaScript.** The packages load untrusted, so only declarations apply. That is
+  what lets you put an SSO live without anyone reviewing code.
+- **Stamping is not installing.** A stamped package applies before sign-in only; inside the organization
+  what applies is what the organization installed, from the Extensions screen. To have both, do both.
+
+\`deploy\` refuses a package that contributes to nothing which works before sign-in, rather than stamping
+it: it would load with no effect, and you would believe it was live.
+
 \`unpack\` and \`deploy\` are separate so that taking a new version does not oblige you to publish
 everything, and so that there is a moment between the two to fill in a setting the new version asks for.
 

package/lib/vendor/pack.js

@@ -4,7 +4,7 @@ import { flagValue, hasFlag } from '../shared/args.js';
 import { repoRoot } from '../shared/paths.js';
 import { run } from '../shared/run.js';
 import { blank, bullets, heading, info, step, success } from '../shared/ui.js';
-import { DEFAULT_FUNCTIONS_REGION, KERNEL_COMPONENTS, KERNEL_DISTRIBUTION_ID, MANUAL_PREREQUISITES, MINIMUM_CLI_VERSION, REQUIRED_NODE_VERSION, callableFunctionNames, declaredParametersIn, exportedFunctionNames, parseKernelVersion, } from '../kernel/manifest.js';
+import { DEFAULT_FUNCTIONS_REGION, KERNEL_COMPONENTS, KERNEL_DISTRIBUTION_ID, MANUAL_PREREQUISITES, MINIMUM_CLI_VERSION, REQUIRED_NODE_VERSION, callableFunctionNames, declaredParametersIn, exportedFunctionNames, parseKernelVersion, parsePreLoginPoints, } from '../kernel/manifest.js';
 import { digestOfFile } from '../shared/digest.js';
 import { kernelTarballName } from '../kernel/channel.js';
 import { baselineFunctionsOf, baselineIndexesOf, claimProblems, claimsFromTemplates, } from '../kernel/backendShape.js';
@@ -123,6 +123,7 @@ export const pack = async (args) => {
      */
     const changelog = await readChangelog(root, KERNEL_CHANGELOG, version);
     const kernelVersion = parseKernelVersion(await readFile(join(root, 'src/domain/schema/plugin/kernelVersion.ts'), 'utf8'));
+    const preLoginPoints = parsePreLoginPoints(await readFile(join(root, 'src/domain/schema/plugin/preLoginPoints.ts'), 'utf8'));
     const functionNames = exportedFunctionNames(await readFile(join(root, 'functions/src/index.ts'), 'utf8'));
     const scan = await scanBackendSources(join(root, 'functions/src'));
     const backendParameters = scan.parameters;
@@ -225,6 +226,7 @@ export const pack = async (args) => {
         baselineFunctions,
         baselineIndexes,
         callables,
+        preLoginPoints,
         backendParameters,
         manualPrerequisites: MANUAL_PREREQUISITES,
         sdk,

package/package.json

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