synthesisui 0.16.421 → 0.16.423

package/dist/project-facts.js

@@ -14,7 +14,7 @@
  * emits. It renders completely unstyled, and nothing anywhere reports a problem.
  */
 import { readdir, readFile } from "node:fs/promises";
-import { join, relative } from "node:path";
+import { join, relative, sep } from "node:path";
 import { DEFAULT_CONVENTION, } from "./component-codegen.js";
 /**
  * Which React the consumer is on, for the ref-carrying prop type.
@@ -172,42 +172,148 @@ export async function readInstalledScheme(root, slug) {
     }
 }
 /**
- * O QUE A FOLHA INSTALADA DECLARA NO `@theme` - a resposta que decide de quem é o VALOR.
+ * O QUE O `@theme` **DELE** DECLARA, NO APP ONDE O COMPONENTE VAI VIVER - e desde 11/09 é esta a
+ * resposta que decide o utilitário.
  *
- * O QUE O CLIENTE PERCEBE SEM ISTO: o componente sai vestindo `rounded-lg` e `font-mono`, a classe
- * existe em qualquer projeto com Tailwind, e ela pinta o **default do Tailwind** em vez do raio e da
- * fonte do sistema dele. Nada falta na tela - é a mesma peça com os números de outra biblioteca, o
- * que é mais difícil de achar que uma classe morta.
+ * O QUE O CLIENTE GANHA: o componente sai vestindo `rounded-lg` só quando `rounded-lg` já pinta o
+ * raio DELE - porque o `@theme` daquele app declara `--radius-lg`. Onde ele não declara, sai o
+ * valor arbitrário, que a porta de tradução resolve no nome dele ou no literal. Nos dois casos o
+ * arquivo funciona sem nenhuma folha nossa carregada.
  *
- * A folha deixa de declarar por dois motivos legítimos: o alinhamento tirou a linha para não roubar
- * uma classe que o app dele já usa (`INV-VOLTA-13`), ou o compilador não faz ponte para um nome que
- * não está em `meta.ownedNames`. Os dois se leem no mesmo lugar - o arquivo que caiu na pasta dele -
- * e é por isso que a pergunta é respondida AQUI e não no servidor: só nesta máquina existe a folha
- * que ele realmente tem.
+ * A PERGUNTA MUDOU DE LADO, e é a metade que faltava de `INV-GERAL-13`. Até aqui quem respondia era
+ * `installedThemeVars`, sobre a NOSSA folha: o codegen escrevia `rounded-lg` quando o nosso
+ * `theme.css` declarava `--radius-lg`, e aquela linha só existe dentro de um arquivo que o app dele
+ * teria que importar. Ou seja, o utilitário nomeado era a última dependência de runtime da nossa
+ * folha - invisível, porque a classe existe em qualquer projeto com Tailwind e pinta o default sem
+ * nada faltar na tela.
  *
- * MEDIDO em 07/09 sobre todos os componentes: 58 de 110 utilitários de token no `codelevel` (53%) e
- * 34 de 241 no `ember` (14%) não carregavam o valor do sistema.
+ * `null` É UMA RESPOSTA, e ela significa **não sei** - nunca "ele não declara nada". Os dois casos
+ * existem de verdade e pedem coisas opostas:
  *
- * `null` quando não há folha - projeto sem `add`, ou install antigo. Nesse caso nada pinta de
- * qualquer forma, e o `refit`/`generate` já dizem isso.
+ *     nenhum `@theme` em lugar nenhum   Tailwind v3 (o tema mora no `tailwind.config`), ou projeto
+ *                                       sem Tailwind. Ali `rounded-lg` PODE pintar o valor dele, e
+ *                                       responder "vazio" faria todo utilitário virar valor
+ *                                       arbitrário - a régua acerta o argumento e erra o projeto
+ *     um `@theme` que não declara ISTO  aí o conjunto vem preenchido e a ausência é um fato
+ *
+ * Quem chama trata `null` como o `minted` sempre tratou: o nome legível fica, porque não há medição
+ * que o contradiga.
+ *
+ * A RESPOSTA É DO APP, E NÃO DO REPOSITÓRIO - e essa é a lição de `INV-VOLTA-12`, que saiu do
+ * produto com a instrução de import e não com a topologia. Num monorepo, varrer da raiz faz o
+ * `@theme` do app A responder por um componente escrito no app B: emitimos `bg-brand`, aquele app
+ * não gera a classe, e a propriedade renderiza NADA - pior que o valor arbitrário, porque nada
+ * falta na tela.
+ *
+ * A RESPOSTA É A INTERSEÇÃO DOS APPS, mais o que é compartilhado - ver o corpo. Um componente
+ * materializado vai para uma pasta que num monorepo os dois apps importam, e ele não sabe em qual
+ * será usado: o nome só é seguro quando vale em todos.
  */
-export async function installedThemeVars(root, slug) {
-    const dir = join(root, "_synthesisui", "ds", slug);
-    const version = await pinnedVersion(dir);
-    if (!version)
-        return null;
-    const css = await readFile(join(dir, `v${version}`, "theme.css"), "utf8").catch(() => "");
-    if (!css)
-        return null;
+export async function theirThemeVars(root, 
+/**
+ * As pastas de app deste repositório - `detectAppDirs`. Vazia num projeto de um app só, que é a
+ * maioria, e aí a resposta é a do repositório inteiro.
+ */
+apps = []) {
+    const shared = new Set();
+    let sawTheme = false;
+    const collect = async (dir, into, skipApps) => {
+        const walk = async (at) => {
+            for (const entry of await readdir(at, { withFileTypes: true }).catch(() => [])) {
+                if (SKIP.has(entry.name) || entry.name.startsWith("."))
+                    continue;
+                const path = join(at, entry.name);
+                const rel = relative(root, path).split(sep).join("/");
+                /** Ao varrer o compartilhado, toda pasta que É app (ou contém uma) fica de fora. */
+                if (skipApps &&
+                    apps.some((app) => app === rel || app.startsWith(`${rel}/`)))
+                    continue;
+                if (entry.isDirectory())
+                    await walk(path);
+                else if (/\.css$/i.test(entry.name)) {
+                    const css = await readFile(path, "utf8").catch(() => "");
+                    if (!THEME_BLOCK.test(css))
+                        continue;
+                    sawTheme = true;
+                    for (const name of themeVarsIn(css))
+                        into.add(name);
+                }
+            }
+        };
+        await walk(dir);
+    };
+    /** O que NÃO mora em nenhum app: o pacote compartilhado, e ele vale para todos. */
+    await collect(root, shared, apps.length > 0);
+    if (apps.length === 0)
+        return sawTheme ? shared : null;
     /**
-     * Só o que está DENTRO de um `@theme` conta - é a única coisa que o Tailwind v4 lê para gerar
-     * utilitário. Uma variável no `[data-ds]` do `tokens.css` não gera nada, e foi tratar as duas como
-     * iguais que fez o `theme.css` parecer suficiente quando não era.
+     * E O QUE CADA APP DECLARA, INTERSECTADO - porque um componente materializado não sabe em qual
+     * app vai ser usado.
+     *
+     * `components/<nome>/` num monorepo é compartilhado por construção. Se o app A declara
+     * `--color-brand` e o B não, escrever `bg-brand` entrega uma propriedade que renderiza NADA no B -
+     * pior que o valor arbitrário, porque nada falta na tela. A interseção é a única resposta que vale
+     * em qualquer um deles, e ela degrada para "o que o repositório declara" quando há um app só.
      */
-    const blocks = css.matchAll(/@theme[^{]*\{([\s\S]*?)\n\}/g);
-    const declared = new Set();
-    for (const block of blocks)
-        for (const m of block[1].matchAll(/^\s*(--[a-zA-Z0-9-]+)\s*:/gm))
-            declared.add(m[1]);
-    return declared;
+    let common = null;
+    for (const app of apps) {
+        const mine = new Set(shared);
+        await collect(join(root, ...app.split("/")), mine, false);
+        if (common === null)
+            common = mine;
+        else
+            for (const name of [...common])
+                if (!mine.has(name))
+                    common.delete(name);
+    }
+    return sawTheme ? (common ?? shared) : null;
+}
+/** As pastas que nenhuma varredura de CSS dele deve entrar - `_synthesisui/` é NOSSA. */
+const SKIP = new Set([
+    "node_modules",
+    ".git",
+    "dist",
+    ".next",
+    "build",
+    "out",
+    "_synthesisui",
+]);
+/** Existe um `@theme` neste texto? - a pergunta que separa "não declara" de "não sei". */
+const THEME_BLOCK = /@theme[^{]*\{/;
+/**
+ * Os nomes declarados dentro de um `@theme { … }` - a única coisa que o Tailwind v4 lê para gerar
+ * utilitário. Uma variável no `:root` não gera classe nenhuma, e tratar as duas como iguais foi o
+ * que fez o `theme.css` parecer suficiente quando não era.
+ *
+ * NADA AQUI ASSUME COMO ELE FORMATA - e essa suposição era legítima enquanto esta função lia a
+ * NOSSA folha, que nós escrevemos. Ela deixou de ser no instante em que a pergunta mudou de lado.
+ *
+ * As duas âncoras antigas eram nossas: `\n\}` para fechar o bloco (uma folha com `@theme { … }`
+ * numa linha só nunca fechava) e `^\s*--nome:` para a declaração (nenhuma delas começa a linha num
+ * arquivo minificado). Nos dois casos o conjunto saía VAZIO, e vazio não é "não declara": é todo
+ * utilitário nomeado virando valor arbitrário, calado.
+ *
+ * O bloco é contado por CHAVES, e a declaração é delimitada pela pontuação - `{` ou `;` antes, e
+ * `;` ou `}` depois, este em lookahead para que o `;` de uma declaração possa abrir a próxima. É a
+ * mesma correção que `their-tongue.ts` recebeu no mesmo diff, pelo mesmo motivo.
+ */
+function themeVarsIn(css) {
+    const out = [];
+    for (const m of css.matchAll(/@theme[^{]*\{/g)) {
+        let depth = 1;
+        let i = (m.index ?? 0) + m[0].length;
+        const start = i;
+        for (; i < css.length && depth > 0; i += 1) {
+            const c = css[i];
+            if (c === "{")
+                depth += 1;
+            else if (c === "}")
+                depth -= 1;
+        }
+        for (const d of css
+            .slice(start, i - 1)
+            .matchAll(/(?:^|[{;])\s*(--[a-zA-Z0-9-]+)\s*:\s*[^;}]+(?=[;}]|$)/g))
+            out.push(d[1]);
+    }
+    return out;
 }

package/dist/recipe-css.js

@@ -0,0 +1,249 @@
+/**
+ * AS REGRAS DE RECEITA QUE UMA PÁGINA VESTE, COPIADAS PARA O CSS DELA.
+ *
+ * O QUE O CLIENTE GANHA: a página que o `template` escreve renderiza sem nenhuma folha nossa
+ * carregada no app dele. Ela veste `.ds-hero`, `.ds-nav` e as outras classes que o sistema declara,
+ * e essas regras passam a morar no `.css` colocalizado ao lado da própria página - traduzidas para
+ * o vocabulário dele, como todo o resto.
+ *
+ * O QUE ISTO SUBSTITUI. Uma página é a única materialização que depende da folha por CLASSE, e não
+ * por variável: a tradução (`their-tongue.ts`) reescreve `var(--ds-*)` e não tem o que fazer com
+ * `.ds-hero`, porque o corpo daquela regra nunca esteve no arquivo. Enquanto isso fosse verdade, o
+ * `template` terminava mandando instalar o sistema e colar um `@import` - a instrução que
+ * `INV-GERAL-13` proíbe, e a última que sobrava no produto.
+ *
+ * A PÁGINA VESTE TRÊS CAMADAS, e a primeira versão desta cópia lia UMA.
+ *
+ * A folha compilada escopa no mesmo `[data-ds]` três coisas diferentes, e a revisão do fecho mediu
+ * o que ficava para trás:
+ *
+ *     `@layer components`   uma regra por receita - `.ds-hero`, `.ds-nav`
+ *     `@layer base`         o CHÃO do sistema (cor do texto e família do corpo), o piso de
+ *                           `:focus-visible`, e o bloco de `prefers-reduced-motion`
+ *     `@layer utilities`    os utilitários DELE que a folha espelha
+ *
+ * Copiar só a primeira entregava a página com as receitas e SEM o chão de tipografia, sem o anel de
+ * foco e sem a regra de movimento reduzido - uma regra de acessibilidade que o sistema declara e
+ * que sumiria sem uma linha em lugar nenhum, sob um terminal dizendo *"nothing to install: this page
+ * and its stylesheet stand on their own"*.
+ *
+ * O QUE A CÓPIA DESFAZ É UMA COISA SÓ: o `@layer`. As camadas existem para o CSS dele poder
+ * sobrescrever o nosso sem disputa de especificidade, e isso só faz sentido dentro de uma folha que
+ * traz as duas metades. Soltas no arquivo dele, elas mudariam a ordem de cascata daquele arquivo.
+ *
+ * O `[data-ds="<slug>"]` FICA, e ele é o que impede o vazamento. A página que o `template` escreve
+ * já nasce dentro de um wrapper com esse atributo - é assim que o CSS colocalizado dela sempre
+ * aplicou -, então o seletor resolve. Desescopar transformaria `.ds-button` numa regra global no
+ * app inteiro dele, e um `import "./landing.css"` não isola nada: seria a nossa folha entrando pela
+ * porta que esta etapa acabou de fechar.
+ *
+ * O QUE ELA NÃO FAZ: inventar regra. Só as classes que a página REALMENTE veste são copiadas, e o
+ * que a folha não declara não vira nada - a página perde aquilo do mesmo jeito que perderia hoje,
+ * e quem chama diz o quê.
+ */
+/**
+ * O corpo de CADA `@layer { … }` da folha, com as chaves de dentro contadas.
+ *
+ * O nome da camada não filtra nada: `base`, `components` e `utilities` carregam, todas as três,
+ * regras escopadas que a página veste. O que decide se uma regra é copiada é a CLASSE que ela
+ * declara e que o arquivo escreve - a mesma pergunta em qualquer camada.
+ */
+function layerBodies(css) {
+    const out = [];
+    for (const m of css.matchAll(/@layer\s+[\w-]+\s*\{/g)) {
+        let depth = 1;
+        let i = (m.index ?? 0) + m[0].length;
+        const start = i;
+        for (; i < css.length && depth > 0; i += 1) {
+            const c = css[i];
+            if (c === "{")
+                depth += 1;
+            else if (c === "}")
+                depth -= 1;
+        }
+        out.push(css.slice(start, i - 1));
+    }
+    return out;
+}
+/**
+ * AS REGRAS DE UM CORPO DE CAMADA, uma a uma - prelúdio + bloco.
+ *
+ * Uma regra de agrupamento (`@media`, `@supports`) vem inteira, com o corpo dela: cortá-la ao meio
+ * produziria CSS inválido, e as media queries são justamente onde mora o comportamento responsivo
+ * que a página precisa manter.
+ */
+function rulesIn(body) {
+    const out = [];
+    let i = 0;
+    let start = 0;
+    while (i < body.length) {
+        if (body[i] !== "{") {
+            i += 1;
+            continue;
+        }
+        const prelude = body.slice(start, i).trim();
+        let depth = 1;
+        let j = i + 1;
+        for (; j < body.length && depth > 0; j += 1) {
+            if (body[j] === "{")
+                depth += 1;
+            else if (body[j] === "}")
+                depth -= 1;
+        }
+        if (prelude)
+            out.push({ prelude, block: body.slice(i + 1, j - 1) });
+        i = j;
+        start = j;
+    }
+    return out;
+}
+/** Os nomes de classe que um prelúdio de seletor menciona - `sm\:ds-hero` conta como `ds-hero`. */
+function classesOf(prelude) {
+    const out = [];
+    for (const m of prelude.matchAll(/\.((?:\\.|[\w-])+)/g)) {
+        const bare = m[1].replace(/\\(.)/g, "$1");
+        out.push((bare.split(":").pop() ?? bare).replace(/^[!-]/, ""));
+    }
+    return out;
+}
+/**
+ * A REGRA É O ATRIBUTO, E NÃO A FUNÇÃO - e esta capacidade já estava provada antes de nascer aqui.
+ *
+ * A primeira versão desta função casava só o valor LITERAL de `class`/`className`. Funcionava porque
+ * o NOSSO gerador emite literal - ou seja, a régua estava calibrada na forma da nossa própria saída,
+ * e o refino que o próprio cabeçalho da página manda ele fazer a deixava para trás.
+ *
+ * `sheet-needed.ts`, apagado nesta mesma etapa, já tinha resolvido isso, com a medição escrita:
+ * `className={cn(…)}` aparece **66 vezes em `packages/ui/src` e 239 em `apps/web-dashboard`** do
+ * `frontend-hub` (08/09) - 305 sítios onde a pergunta era feita sobre um texto que não continha a
+ * resposta. Uma capacidade provada não se reimplementa mais fraca porque o módulo mudou de nome.
+ *
+ * POR QUE NÃO O NOME DA FUNÇÃO: casar `cn|clsx|twMerge` seria a lista dos casos de hoje - o próximo
+ * projeto chama a dele de `cx`, `classes`, ou passa um ternário direto. O que é estrutural é o
+ * ATRIBUTO: dentro do valor de um `class`/`className`, toda string literal é candidata a classe.
+ *
+ * O QUE ISTO NÃO ALCANÇA, com o número: a tabela de variantes numa const separada (`cva`, `tv`), que
+ * chega ao atributo por VARIÁVEL. `sheet-needed.ts` seguia a variável; aqui o erro cai para o lado
+ * seguro - uma classe não vista é uma regra não copiada, e a página perde estilo em vez de ganhar
+ * regra que ninguém veste. Quando aparecer uma página que a use, o número dela abre a frente.
+ */
+export function classesWorn(source) {
+    const out = new Set();
+    const collect = (body) => {
+        for (const raw of body.split(/\s+/)) {
+            if (!raw)
+                continue;
+            const bare = raw.split(":").pop() ?? raw;
+            out.add(bare.replace(/^[!-]/, ""));
+        }
+    };
+    for (const m of source.matchAll(/class(?:Name)?=(?:"([^"]*)"|'([^']*)'|\{`([^`]*)`\}|\{"([^"]*)"\})/g))
+        collect(m[1] ?? m[2] ?? m[3] ?? m[4] ?? "");
+    /** E toda string DENTRO da expressão do atributo - ver `attributeExpressions`. */
+    for (const expr of attributeExpressions(source))
+        for (const lit of expr.matchAll(/"([^"]*)"|'([^']*)'|`([^`]*)`/g))
+            collect(lit[1] ?? lit[2] ?? lit[3] ?? "");
+    return out;
+}
+/**
+ * O VALOR DE UM ATRIBUTO DE CLASSE, QUANDO ELE É UMA EXPRESSÃO - copiado de `sheet-needed.ts`, que
+ * saiu nesta etapa, e com a medição que o originou preservada acima.
+ */
+function attributeExpressions(source) {
+    const out = [];
+    const ATTR = /class(?:Name)?=\{/g;
+    for (const m of source.matchAll(ATTR)) {
+        let depth = 0;
+        let i = (m.index ?? 0) + m[0].length - 1;
+        const start = i;
+        /** Aspas contam para NÃO deixar uma chave dentro de string fechar a expressão cedo. */
+        let quote = null;
+        for (; i < source.length; i += 1) {
+            const c = source[i];
+            if (quote) {
+                if (c === "\\")
+                    i += 1;
+                else if (c === quote)
+                    quote = null;
+                continue;
+            }
+            if (c === '"' || c === "'" || c === "`")
+                quote = c;
+            else if (c === "{")
+                depth += 1;
+            else if (c === "}") {
+                depth -= 1;
+                if (depth === 0)
+                    break;
+            }
+        }
+        if (depth === 0)
+            out.push(source.slice(start + 1, i));
+    }
+    return out;
+}
+/**
+ * AS REGRAS QUE ESTA PÁGINA VESTE, desescopadas e prontas para o `.css` ao lado dela.
+ *
+ * `sheetCss` é a folha compilada da versão instalada (`_synthesisui/ds/<slug>/v<n>/tokens.css`) -
+ * o insumo NOSSO, que continua caindo na pasta e que nada no app dele importa.
+ *
+ * O seletor sai como está, escopo incluído: a página vive dentro do wrapper que o carrega, e é ele
+ * que mantém estas regras dentro da página em vez de soltas no app dele.
+ */
+export function recipeRulesFor(input) {
+    const worn = classesWorn(input.source);
+    const out = [];
+    const classes = new Set();
+    for (const body of layerBodies(input.sheetCss))
+        for (const { prelude, block } of rulesIn(body)) {
+            /** Uma regra de agrupamento entra inteira quando algo dentro dela é vestido. */
+            const names = prelude.startsWith("@")
+                ? [...classesOf(prelude), ...classesOf(block)]
+                : classesOf(prelude);
+            const hit = names.filter((n) => worn.has(n));
+            if (hit.length === 0)
+                continue;
+            for (const n of hit)
+                classes.add(n);
+            out.push(`${prelude.replace(/\s+/g, " ").trim()} {${block}}`);
+        }
+    return {
+        css: out.join("\n"),
+        rules: out.length,
+        classes: [...classes].sort(),
+    };
+}
+/**
+ * A FOLHA COMPILADA DA VERSÃO INSTALADA - o insumo NOSSO, de onde as regras são copiadas.
+ *
+ * A folha da raiz é um re-export de uma linha (`@import "./v<n>/tokens.css"`), então quem tem as
+ * regras é o arquivo da versão; o `.lock` diz qual é. Vazio quando não há pasta - e aí não há o que
+ * copiar, o que é uma resposta e não uma falha.
+ */
+export async function installedSheetCss(root, slug) {
+    const { readFile } = await import("node:fs/promises");
+    const { join } = await import("node:path");
+    const dir = join(root, "_synthesisui", "ds", slug);
+    const lock = await readFile(join(dir, ".lock"), "utf8").catch(() => null);
+    let version = 0;
+    if (lock) {
+        try {
+            version = JSON.parse(lock).version ?? 0;
+        }
+        catch {
+            version = 0;
+        }
+    }
+    const versioned = await readFile(join(dir, `v${version}`, "tokens.css"), "utf8").catch(() => "");
+    if (versioned)
+        return versioned;
+    return readFile(join(dir, "tokens.css"), "utf8").catch(() => "");
+}
+/**
+ * O CABEÇALHO DO BLOCO COPIADO - procedência, e nenhuma instrução.
+ *
+ * Ele responde a pergunta de quem abre o arquivo depois ("de onde vieram estas regras?") sem pedir
+ * nada. A versão anterior deste produto respondia a mesma pergunta mandando importar a folha.
+ */
+export const RECIPE_HEADER = "/* From your design system, copied here so this page needs no stylesheet of ours. */";

package/dist/skills.js

@@ -1,6 +1,5 @@
 import { ADAPT_SKILL, ADAPT_SKILL_PATH } from "./skill-adapt.js";
 import { COMPOSE_SKILL, COMPOSE_SKILL_PATH } from "./skill-compose.js";
-import { CONFIGURE_SKILL, CONFIGURE_SKILL_PATH } from "./skill-configure.js";
 import { IMPORT_SKILL, IMPORT_SKILL_PATH } from "./skill-import.js";
 import { INIT_SKILL, INIT_SKILL_PATH } from "./skill-init.js";
 /**
@@ -11,6 +10,11 @@ import { INIT_SKILL, INIT_SKILL_PATH } from "./skill-init.js";
  * conta própria, rodasse `connect` de novo. Ninguém roda um comando de novo sem motivo.
  *
  * É a lei 8 no caso mais barato dela: a lacuna existe, a gente sabe qual é, e dizer custa uma linha.
+ *
+ * ERAM CINCO E SÃO QUATRO desde 11/09: `/sui-configure-ds` existia para fazer os tokens chegarem ao
+ * navegador dele pelo `@import` da nossa folha, e nenhum app dele carrega nada nosso
+ * (`INV-GERAL-13`). Quem já tem o arquivo é avisado pelo `connect`, que o NOMEIA sem apagá-lo -
+ * ver `RETIRED_SKILLS`.
  */
 export const SKILLS = [
     {
@@ -54,19 +58,4 @@ export const SKILLS = [
         label: "/sui-compose",
         what: "build what the system does not have",
     },
-    /**
-     * A DE LIGAR O SISTEMA NO APP, e ela é a única aqui que fecha um passo que a esteira já sabia
-     * diagnosticar e não sabia resolver.
-     *
-     * O `add` IMPRIME a fiação, o `doctor` CONFERE a fiação com três ✓/✗, e nada a ESCREVE. Enquanto
-     * ela falta, os tokens não chegam ao navegador e o `doctor --fix` fica recusado de propósito - um
-     * fix num projeto sem fiação trocou 210 literais por variáveis que o navegador não resolvia e mudou
-     * a página (06/08).
-     */
-    {
-        path: CONFIGURE_SKILL_PATH,
-        source: CONFIGURE_SKILL,
-        label: "/sui-configure-ds",
-        what: "the tokens, loaded by your app",
-    },
 ];