synthesisui 0.16.197 → 0.16.199

package/dist/commands/align.js

@@ -188,6 +188,43 @@ opts = {}) {
  * Melhor esforço: offline, sem sessão, ou registry fora do ar não produzem linha nenhuma. Uma
  * verificação de abertura não pode transformar um voo sem internet num aviso.
  */
+/**
+ * O QUE DIZER QUANDO A PLATAFORMA ENDIREITOU ALGO - e como voltar ao que se estava fazendo.
+ *
+ * O pedido do dono, em 10/08: o agente checa se mudou alguma coisa, diz o comando, e devolve a linha
+ * que retoma a sessão de onde ela parou. A retomada não é conforto - sem ela, a pessoa roda o
+ * comando, perde o contexto do que estava fazendo, e o custo do conserto passa a ser a tarefa que ela
+ * estava no meio.
+ */
+const REPAIR_SAID = {
+    spacing: "spacing values in your system were connected to the steps your own scale declares",
+    orphans: "recipes your measured scope no longer declares were removed",
+    roles: "colour roles were pointed at the ramps your repository declares",
+    reground: "the foundation was rebuilt from your census",
+    interpretation: "your census was re-read with a newer interpretation",
+};
+export function repairSaid(body, lock) {
+    if (!lock.slug)
+        return null;
+    if (!body.repairedAt)
+        return null;
+    /**
+     * SEM CARIMBO LOCAL, SILÊNCIO. Um repo instalado antes de `installedAt` existir não tem com o que
+     * comparar, e avisar sempre transformaria este aviso em ruído permanente - que é como um aviso
+     * deixa de ser lido.
+     */
+    if (!lock.fetchedAt)
+        return null;
+    if (Date.parse(body.repairedAt) <= Date.parse(lock.fetchedAt))
+        return null;
+    const what = body.repaired ? REPAIR_SAID[body.repaired] : undefined;
+    return {
+        says: `Something was put right in "${lock.slug}" on the platform after this repo installed it${what ? `: ${what}` : ""}. The files here still hold what was measured before that.`,
+        run: `npx synthesisui upgrade ${lock.slug}`,
+        /** E o caminho de volta para o que ela estava fazendo. */
+        then: "claude --continue --dangerously-skip-permissions",
+    };
+}
 export async function versionBehind(root, opts = {}) {
     const locks = (await locksIn(root)).filter((l) => l.slug && !l.adopted);
     const lock = locks[0];
@@ -210,6 +247,24 @@ export async function versionBehind(root, opts = {}) {
     const body = (await res.json().catch(() => null));
     if (!body?.version)
         return null;
+    /**
+     * ALGO FOI ENDIREITADO NA PLATAFORMA DESDE QUE ESTE REPO INSTALOU.
+     *
+     * `version` responde "publicaram algo mais novo". O Apply do Studio não publica - ele escreve o
+     * rascunho -, então a versão fica parada e este comando ficava mudo sobre uma mudança real no
+     * design system dele (dono, 10/08). Quem descobre por acaso duas semanas depois é quem deixa de
+     * confiar no que a esteira diz.
+     *
+     * A frase é escrita AQUI, com o texto de hoje: só a data e a chave viajam pela rede. Uma frase que
+     * atravessa a rede congela na versão que a mandou.
+     *
+     * E ela vem ANTES do teste de versão de propósito: quando os dois são verdade, o reparo é a causa e
+     * a versão é a consequência - dizer a consequência primeiro manda a pessoa rodar o comando sem
+     * saber por quê.
+     */
+    const repaired = repairSaid(body, lock);
+    if (repaired)
+        return repaired;
     if (body.version > lock.version)
         return {
             says: `v${body.version} of "${lock.slug}" is published and this repo is on v${lock.version}. The CSS here and the rules your agent reads are both v${lock.version} - they move together, which is why this is worth saying rather than applying.`,
@@ -273,7 +328,8 @@ from = "session") {
             : from === "shell"
                 ? "This repo is out of alignment with the design system that governs it:"
                 : "Before this session starts, this environment is out of alignment with the design system that governs it:",
-        ...items.map((m) => `  - ${m.says}${m.run ? `\n      ${m.run}` : ""}`),
+        /** O `then` sai numa linha própria e rotulada: um segundo comando solto lê como parte do primeiro. */
+        ...items.map((m) => `  - ${m.says}${m.run ? `\n      ${m.run}` : ""}${m.then ? `\n      then, to pick up where you left off:\n      ${m.then}` : ""}`),
     ].join("\n");
 }
 /**

package/dist/doctor/components-scan.js

@@ -2,14 +2,146 @@ import { readdir, readFile } from "node:fs/promises";
 import { join } from "node:path";
 /**
  * Opens a JSX element whose name is capitalised - which is React's own rule for
- * "this is a component, not an html tag".
+ * "this is a component, not an html tag". The name allows dots (`Card.Header`).
  *
- * The name allows dots (`Card.Header`) and the body is captured lazily up to
- * the first `>` that is not inside a quoted value.
+ * SÓ A ABERTURA. O corpo NÃO vem daqui - ver `bodyOf`.
  */
-const ELEMENT = /<([A-Z][A-Za-z0-9_]*(?:\.[A-Z][A-Za-z0-9_]*)*)(\s[^>]*?)?\/?>/gs;
-/** `variant="primary"` or `variant={"primary"}` - a literal a person typed. */
-const LITERAL_PROP = /([a-zA-Z][a-zA-Z0-9_-]*)\s*=\s*\{?\s*["']([^"']*)["']\s*\}?/g;
+const OPENS = /<([A-Z][A-Za-z0-9_]*(?:\.[A-Z][A-Za-z0-9_]*)*)/g;
+/**
+ * ONDE A TAG TERMINA DE VERDADE - e isto era uma varredura de caractere.
+ *
+ * O corpo era `(\s[^>]*?)?`: para no primeiro `>` que aparecer, sem saber o que é aspa e
+ * sem saber o que é aninhamento. Medido no repositório do dono em 10/08, isso produzia
+ * DOIS defeitos que pareciam não ter relação:
+ *
+ *   <WidgetCard rightTitleSlot={ <Button variant="neutral" onClick={() => …
+ *     os atributos do FILHO caem no corpo do PAI - o censo registrou `variant: neutral`
+ *     no WidgetCard, que declara `default | left-border | full-border`. A tela reportou
+ *     "uso fora do contrato" sobre um uso que nunca existiu.
+ *
+ *   value="… Domain 'sg.futurescope.com' … the 'Sending' tab …"
+ *     a aspa simples dentro da dupla fechava o valor cedo, o resto da frase ficava no
+ *     corpo, e o passe de booleano nu colhia palavra por palavra: `the`, `following`,
+ *     `registrar`, `domains`. Dezenove palavras viraram props do Textarea.
+ *
+ * Um defeito INVENTADO é pior que um não achado: o não achado custa uma lacuna, o
+ * inventado custa a confiança na tela inteira. Por isso a resposta não é acrescentar
+ * casos à regex - é um scanner que sabe o que está lendo, e que fecha por construção.
+ *
+ * Devolve o corpo e onde continuar a varredura. Uma tag sem fechamento (arquivo cortado,
+ * TypeScript genérico que não era elemento) devolve `null` e não vira uso.
+ */
+function bodyOf(source, from) {
+    let quote = null;
+    let depth = 0;
+    for (let i = from; i < source.length; i++) {
+        const ch = source[i];
+        if (quote) {
+            /** Escape dentro de string: `\"` não fecha nada. */
+            if (ch === "\\")
+                i += 1;
+            else if (ch === quote)
+                quote = null;
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === "`") {
+            quote = ch;
+            continue;
+        }
+        if (ch === "{")
+            depth += 1;
+        else if (ch === "}")
+            depth -= 1;
+        /** Em profundidade zero e fora de aspas: aqui a tag realmente fecha. */ else if (ch === ">" &&
+            depth <= 0)
+            return {
+                body: withoutExpressions(source.slice(from, i)).replace(/\/$/, ""),
+                end: i + 1,
+            };
+    }
+    return null;
+}
+/**
+ * O QUE ESTÁ DENTRO DE CHAVES NÃO É PROP DESTA TAG - e sem isto o corpo termina no lugar certo
+ * e ainda entrega o filho errado.
+ *
+ * `<WidgetCard rightTitleSlot={<Button variant="neutral" />} />` fecha corretamente no `/>` do
+ * WidgetCard: o `>` do Button está em profundidade 1. Mas o corpo continua carregando
+ * `variant="neutral"`, porque a atribuição do filho mora dentro da expressão do slot.
+ *
+ * Então a expressão vira espaço - e o que ela contém não se perde: o `<Button` dentro dela é
+ * encontrado pela própria varredura, no lugar dele, com as props dele.
+ *
+ * COM UMA EXCEÇÃO, E ELA É MEDIDA: `variant={"info"}` é o MESMO literal que `variant="info"`, e um
+ * spec já dizia isso. A primeira versão deste passe apagava os dois e a suíte reprovou - eu tinha
+ * escrito no comentário que o `LITERAL_PROP` via o corpo cru antes, o que o código não fazia. Uma
+ * chave contendo só um literal volta como valor; qualquer outra coisa dentro é expressão.
+ */
+function withoutExpressions(body) {
+    let out = "";
+    let inner = "";
+    let depth = 0;
+    let quote = null;
+    /** Fecha uma expressão: um literal puro é VALOR e volta; o resto é do que estiver dentro. */
+    const close = () => {
+        out += /^\s*(["'`])(?:\\.|(?!\1)[^\\])*\1\s*$/.test(inner)
+            ? `{${inner}}`
+            : " ";
+        inner = "";
+    };
+    for (let i = 0; i < body.length; i++) {
+        const ch = body[i];
+        const keep = (text) => {
+            if (depth === 0)
+                out += text;
+            else
+                inner += text;
+        };
+        if (quote) {
+            if (ch === "\\") {
+                keep(body.slice(i, i + 2));
+                i += 1;
+            }
+            else {
+                keep(ch);
+                if (ch === quote)
+                    quote = null;
+            }
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === "`") {
+            quote = ch;
+            keep(ch);
+            continue;
+        }
+        if (ch === "{") {
+            depth += 1;
+            if (depth > 1)
+                inner += ch;
+            continue;
+        }
+        if (ch === "}") {
+            depth -= 1;
+            if (depth === 0)
+                close();
+            else if (depth > 0)
+                inner += ch;
+            else
+                depth = 0;
+            continue;
+        }
+        keep(ch);
+    }
+    return out;
+}
+/**
+ * `variant="primary"` ou `variant={'primary'}` - um literal que alguém digitou.
+ *
+ * A ASPA CASA COM ELA MESMA (`(["'])…\2`), e não com qualquer uma. `["']([^"']*)["']`
+ * tratava as duas como intercambiáveis, então um valor com apóstrofo dentro truncava - e o
+ * que sobrava virava prop. Ver `bodyOf`.
+ */
+const LITERAL_PROP = /([a-zA-Z][a-zA-Z0-9_-]*)\s*=\s*\{?\s*(["'])((?:\\.|(?!\2)[^\\])*)\2\s*\}?/g;
 /** `dense` with no value is a boolean prop set to true, and that IS a literal
  *  decision worth counting. */
 const BARE_PROP = /(^|\s)([a-z][a-zA-Z0-9_]*)(?=\s|$)/g;
@@ -171,8 +303,12 @@ internal = []) {
         return;
     const owners = importedNames(source, internal);
     const private_ = localOnlyNames(source);
-    ELEMENT.lastIndex = 0;
-    for (const m of source.matchAll(ELEMENT)) {
+    /**
+     * Abertura por regex, corpo por SCANNER - ver `bodyOf`. A regex só encontra `<Nome`; onde a
+     * tag termina é uma pergunta que só um scanner com estado responde.
+     */
+    OPENS.lastIndex = 0;
+    for (const m of source.matchAll(OPENS)) {
         if (m.index != null && looksLikeType(source, m.index))
             continue;
         const name = m[1];
@@ -180,11 +316,25 @@ internal = []) {
         // shadow nothing and still bind a name it also imports.
         if (!owners.has(name) && private_.has(name.split(".")[0]))
             continue;
-        const body = m[2] ?? "";
+        const read = bodyOf(source, (m.index ?? 0) + m[0].length);
+        /** Tag sem fechamento não é uso: arquivo cortado, ou um genérico que não era elemento. */
+        if (!read)
+            continue;
+        const body = read.body;
         // A dotted name belongs to whoever exported its root (`Popover.Root`).
         const owner = owners.get(name) ?? owners.get(name.split(".")[0]);
-        /** Ver `ComponentTally`: dois `Button` de pacotes diferentes são duas linhas, não uma. */
-        let hit = tally.get(name);
+        /**
+         * A ORIGEM ENTRA NA CHAVE - a lei 13 do CLAUDE.md, que este comentário já afirmava e o código
+         * não cumpria: a chave era só o nome.
+         *
+         * Medido no repositório do dono em 10/08: os apps usam o `Button` DELE e o do MUI, e as
+         * variantes do MUI (`contained`, `outlined`, `text`) caíam na conta do Button dele, que declara
+         * `ocean`, `royal`, `neutral`. O mesmo com `CircularProgress` e `determinate`. E era a mesma
+         * causa do `own: true` valer em 7 de 128: uma linha que mistura duas origens nunca tem TODAS
+         * as origens de dentro.
+         */
+        const key = `${name}\u0000${owner ?? ""}`;
+        let hit = tally.get(key);
         if (!hit) {
             hit = {
                 count: 0,
@@ -194,7 +344,7 @@ internal = []) {
                 ...(owner && owner !== OWN ? { from: owner } : {}),
                 origins: new Set(),
             };
-            tally.set(name, hit);
+            tally.set(key, hit);
         }
         /** TODA origem vista, e não só a primeira - ver `origins` no tipo. */
         if (owner)
@@ -204,7 +354,8 @@ internal = []) {
         LITERAL_PROP.lastIndex = 0;
         const named = new Set();
         for (const p of body.matchAll(LITERAL_PROP)) {
-            const [, prop, value] = p;
+            /** O grupo 2 é a ASPA (a backreference); o valor é o 3 - ver `LITERAL_PROP`. */
+            const [, prop, , value] = p;
             named.add(prop);
             if (NOT_A_DECISION.test(prop))
                 continue;
@@ -239,8 +390,9 @@ internal = []) {
 /** The inventory, commonest first. */
 export function tallyToInventory(tally, max = 80) {
     return [...tally.entries()]
-        .map(([name, v]) => ({
-        name,
+        .map(([key, v]) => ({
+        /** A chave carrega a origem para separar as linhas - o nome é a primeira metade dela. */
+        name: key.split("\u0000")[0],
         ...(v.from ? { from: v.from } : {}),
         /** Só dele quando TODA aparição veio de dentro - ver `origins` e `OWN`. */
         ...(v.origins.size > 0 && [...v.origins].every((o) => o === OWN)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synthesisui",
-  "version": "0.16.197",
+  "version": "0.16.199",
   "description": "Bring SynthesisUI design systems into any project - tokens, typed components, whole pages and an agent-ready CLAUDE.md manifest.",
   "type": "module",
   "bin": {