synthesisui 0.16.261 → 0.16.264

package/dist/memory/tools.js

@@ -0,0 +1,269 @@
+import { randomUUID } from "node:crypto";
+import { sourceLine } from "../agent-provenance.js";
+import { FAMILIES } from "../compose-context.js";
+import { TASKS, } from "./contract.js";
+import { prepareWrite, rejectUnknown } from "./write.js";
+/**
+ * AS DUAS FERRAMENTAS QUE O AGENTE VÊ - e o schema é o contrato, não o runtime.
+ *
+ * Recusar um campo derivado em tempo de execução é a segunda linha de defesa. A primeira é o agente
+ * NUNCA VER esse campo como opção: um schema que oferece `confidence` convida a preenchê-lo, e a
+ * recusa depois vira atrito que ele aprende a contornar. Um spec percorre estes schemas e reprova se
+ * qualquer nome de `DERIVED_FIELDS` aparecer neles.
+ *
+ * DUAS FERRAMENTAS ESTREITAS, e não uma genérica: quanto menos combinatória o schema oferece, menos
+ * estado impossível existe para validar depois. `kind` é enum fechado aqui dentro, para que um campo
+ * inválido para aquele tipo seja estruturalmente impossível em vez de ser um erro de validação.
+ */
+export const MEMORY_TOOLS = [
+    {
+        name: "remember",
+        description: "Record what this project DECIDED, what it deliberately does NOT do, or what someone is working on right now - so the next session does not decide it again. You propose the fact and where it came from; identity, confidence, authority and state are derived from measurement on our side. A work state must carry an exit condition the repository itself can prove, or it is refused: memory that cannot be closed by reality starts lying within weeks.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                request_id: {
+                    type: "string",
+                    description: "Optional id for THIS call, for your own logs. It does not decide anything: writing the same thing twice is already harmless - identity comes from the content, so a retry finds what is there instead of adding to it.",
+                },
+                kind: {
+                    type: "string",
+                    enum: ["decision", "rationale", "work-state"],
+                    description: "decision = what we do · rationale = why we do NOT do something · work-state = what someone is doing now",
+                },
+                text: {
+                    type: "string",
+                    description: "The decision or the reasoning, in one sentence, as a person would say it. Not needed for work-state.",
+                },
+                applies: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "decision only. Empty = the whole system · one name = that component · two = the relation between them.",
+                },
+                rule_kind: {
+                    type: "string",
+                    enum: ["limit", "implementation"],
+                    description: "decision only. limit = a boundary a measurement can check · implementation = how it is built, which no linter catches.",
+                },
+                when: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "decision only. Stack members this holds in - empty means all of them.",
+                },
+                family: {
+                    type: "string",
+                    enum: [...FAMILIES],
+                    description: "decision only, and only when it is about one family.",
+                },
+                tasks: {
+                    type: "array",
+                    items: { type: "string", enum: [...TASKS] },
+                    description: "decision only. Which kinds of work this is relevant to - omit when it is relevant to all.",
+                },
+                subject: {
+                    type: "string",
+                    description: "What this is ABOUT - a token, a component, a library. Required for rationale.",
+                },
+                exit: {
+                    type: "object",
+                    description: "work-state only. The condition the REPOSITORY proves, so nobody has to remember to close this.",
+                    properties: {
+                        type: {
+                            type: "string",
+                            enum: [
+                                "reference_replaced",
+                                "inbound_references_zero",
+                                "reference_present",
+                                "reference_absent",
+                                "token_present",
+                                "token_absent",
+                                "component_present",
+                                "component_absent",
+                            ],
+                        },
+                        subject: { type: "string" },
+                        from: { type: "string" },
+                        to: { type: "string" },
+                    },
+                    required: ["type", "subject"],
+                },
+                created_by: {
+                    type: "string",
+                    enum: ["developer", "agent", "import"],
+                    description: "work-state only. Who put this state here.",
+                },
+                provenance: {
+                    type: "string",
+                    enum: ["developer_declared", "agent_inferred", "imported"],
+                    description: "Where the claim came from. `measured` is not on this list on purpose: only whoever measures can confer it.",
+                },
+                confirmation: {
+                    type: "string",
+                    enum: ["spontaneous", "confirmed_suggestion"],
+                    description: "rationale only. Did they say it unprompted, or confirm something you suggested? Both are human; the difference is worth keeping.",
+                },
+            },
+            required: ["kind", "provenance"],
+        },
+    },
+    {
+        name: "recall",
+        description: "What this project already decided about what you are doing NOW - filtered by scope, stack, family and task, ordered by specificity and confidence, and cut to a token budget YOU declare. The answer says what was left out and by which filter, so nothing disappears silently. Decisions about the same subject always travel together: half of a discussion reads as the whole of it.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                scope: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "The components in play. Leave empty when the question is about the system.",
+                },
+                family: { type: "string", enum: [...FAMILIES] },
+                task: {
+                    type: "string",
+                    enum: [...TASKS],
+                    description: "What kind of work this is - it filters, it does not rank.",
+                },
+                budget: {
+                    type: "number",
+                    description: "How many tokens of memory you can afford right now. Say it honestly: the platform chooses what fits, most trustworthy first.",
+                },
+            },
+            required: ["budget"],
+        },
+    },
+];
+/** Todo nome que aparece num schema, em qualquer profundidade - o spec usa isto. */
+export function fieldNamesIn(schema, found = []) {
+    if (!schema || typeof schema !== "object")
+        return found;
+    const node = schema;
+    if (node.properties && typeof node.properties === "object")
+        for (const [key, value] of Object.entries(node.properties)) {
+            found.push(key);
+            fieldNamesIn(value, found);
+        }
+    if (node.items)
+        fieldNamesIn(node.items, found);
+    return found;
+}
+/** `rule_kind` na porta, `ruleKind` por dentro: o agente escreve snake, o contrato interno é camel. */
+const toWrite = (args) => ({
+    kind: args.kind,
+    text: args.text,
+    applies: args.applies ?? [],
+    ruleKind: args.rule_kind ?? "implementation",
+    when: args.when,
+    family: args.family,
+    tasks: args.tasks,
+    subject: args.subject,
+    exit: args.exit,
+    createdBy: args.created_by ?? "agent",
+    provenance: args.provenance,
+});
+/** O payload como o contrato interno o nomeia - é o que `rejectUnknown` sabe julgar. */
+const RENAMED = {
+    rule_kind: "ruleKind",
+    created_by: "createdBy",
+    request_id: "requestId",
+};
+const answer = (body, detail) => ({
+    body: `${body}\n\n${sourceLine({ kind: "composed", detail })}`,
+    source: { kind: "composed", detail },
+});
+const refuse = (r) => ({
+    body: `Not recorded: ${r.reason}\n${r.details}`,
+    source: { kind: "none", reason: "tool", detail: r.reason },
+});
+/**
+ * A ESCRITA, DO LADO QUE VÊ O REPOSITÓRIO.
+ *
+ * Validação e normalização acontecem aqui porque a observabilidade de uma condição depende do censo,
+ * que está no disco dele. Deduplicação, orçamento e persistência ficam do outro lado, onde o estado
+ * vive - e o `request_id` atravessa intacto para que um retry devolva o resultado da PRIMEIRA
+ * execução em vez de reexecutar contra o estado de agora.
+ */
+export async function handleRemember(args, obs, send, 
+/** O rastro local, opcional - ver `kind: "decision"` em `CheckEvent`. */
+note) {
+    const internal = {};
+    for (const [key, value] of Object.entries(args)) {
+        if (value === undefined)
+            continue;
+        internal[RENAMED[key] ?? key] = value;
+    }
+    /** O `requestId` não é campo de memória: ele é da chamada, e sai antes da checagem de schema. */
+    const requestId = String(internal.requestId ?? randomUUID());
+    delete internal.requestId;
+    const unknown = rejectUnknown(internal);
+    if (unknown)
+        return refuse(unknown);
+    const ready = prepareWrite(toWrite(args), obs);
+    if ("accepted" in ready)
+        return refuse(ready);
+    /**
+     * A IDENTIDADE VEM DE VOLTA, e não daqui. O cliente não sabe quem é o usuário - só tem um token -,
+     * então o fingerprint e o dono são atribuídos do outro lado, onde a sessão existe.
+     */
+    const out = await send({
+        requestId,
+        draft: ready.draft,
+        memory: toWrite(args),
+    });
+    if (!out.accepted)
+        return refuse(out);
+    /**
+     * E O LEDGER LOCAL REGISTRA, sem governar nada.
+     *
+     * `kind: "decision"` é rastro: ele diz que isto foi proposto neste repositório, neste instante, e é
+     * o que o `sync` sobe junto com as checagens. A memória que VALE está do outro lado - apagar o
+     * ledger não muda uma linha do que o `recall` devolve.
+     */
+    await note?.({
+        kind: "decision",
+        at: new Date().toISOString(),
+        file: out.record.subject ?? out.record.kind,
+    });
+    const said = out.action === "existing"
+        ? "This was already known, unchanged."
+        : out.action === "evidence_updated"
+            ? "Already known, and this observation was added to its evidence."
+            : out.action === "co_scoped"
+                ? "Recorded, and it sits alongside another memory on the same subject - both were kept, and neither claims the other is wrong."
+                : "Recorded.";
+    return answer(`${said}\nid ${out.record.fingerprint} · ${out.record.kind}${out.record.subject ? ` · ${out.record.subject}` : ""}`, `memory:${out.action}`);
+}
+/**
+ * A LEITURA - e o CLI não tem as memórias.
+ *
+ * Ele monta o pedido com o teto que o agente declarou e FORMATA o que volta. Filtro, ordem e
+ * orçamento são da plataforma, que é quem tem o acervo, a confiança e o estado - e é ela quem sabe o
+ * que ficou de fora e por qual filtro.
+ */
+export async function handleRecall(args, stack, ask) {
+    const budget = Number(args.budget ?? 0);
+    if (!Number.isFinite(budget) || budget <= 0)
+        return refuse({
+            accepted: false,
+            reason: "unknown_field",
+            details: "budget has to be a positive number of tokens you can afford",
+        });
+    const out = await ask({
+        scope: Array.isArray(args.scope) ? args.scope : [],
+        stack,
+        ...(args.family ? { family: String(args.family) } : {}),
+        ...(args.task ? { task: args.task } : {}),
+        budget,
+    });
+    if (out.carried.length === 0)
+        return {
+            body: `Nothing recorded that applies here. ${out.because}`,
+            source: { kind: "none", reason: "system", detail: "nothing applies" },
+        };
+    const lines = out.carried.map((m) => `- ${m.text}${m.applies.length > 0 ? `  [${m.applies.join(", ")}]` : ""}  (${m.rung})`);
+    const grouped = out.groups.length > 0
+        ? `\n\nSame subject, so they travel together: ${out.groups
+            .map((g) => g.members.join(" + "))
+            .join(" · ")}`
+        : "";
+    return answer(`${lines.join("\n")}${grouped}\n\n${out.because}`, "memory:recall");
+}

package/dist/memory/work-state.js

@@ -0,0 +1,131 @@
+/** Dias distintos com medição, sem progresso, antes de o estado adormecer. */
+export const DORMANT_AFTER_MEASURED_DAYS = 3;
+const day = (iso) => iso.slice(0, 10);
+/** Estados que uma medição não move mais. Uma regressão é um trabalho NOVO, não este voltando. */
+const SETTLED = new Set(["completed", "abandoned"]);
+/**
+ * O QUE A MEDIÇÃO FAZ COM UM ESTADO - a única porta por onde `completed` e `orphaned` entram.
+ *
+ * PROGRESSO É O VEREDITO TER MUDADO, e isso é determinístico sem guardar o repositório inteiro: o
+ * `because` de um predicado de transição sai de "still references X" para "dropped X but does not
+ * reference Y yet" quando metade do trabalho aconteceu. Comparar o veredito anterior com o atual
+ * captura isso sem inventar heurística de diff.
+ */
+export function onMeasurement(state, verdict, at, by, dormantAfter = DORMANT_AFTER_MEASURED_DAYS) {
+    if (SETTLED.has(state.status))
+        return state;
+    /**
+     * INVARIANTE 1 e 2, no mesmo lugar: indeterminado NÃO PODE concluir, e ficar órfão preserva
+     * tudo. `lastVerdict` não é sobrescrito - a última coisa que a gente soube de verdade sobrevive
+     * ao período em que a gente deixou de saber.
+     */
+    if (verdict.state === "indeterminate")
+        return {
+            ...state,
+            status: "orphaned",
+            lastMeasuredAt: at,
+            by: by ?? state.by,
+            resolution: {
+                type: "orphaned",
+                source: "measurement",
+                at,
+                reason: `${verdict.reason}: ${verdict.because}`,
+            },
+        };
+    const progressed = !state.lastVerdict ||
+        state.lastVerdict.state !== verdict.state ||
+        state.lastVerdict.because !== verdict.because;
+    if (verdict.state === "met")
+        return {
+            ...state,
+            status: "completed",
+            evidenceSource: "measurement",
+            lastMeasuredAt: at,
+            lastProgressAt: at,
+            measuredDays: [],
+            lastVerdict: { state: "met", because: verdict.because },
+            by: by ?? state.by,
+            resolution: {
+                type: "completed",
+                source: "measurement",
+                at,
+                reason: verdict.because,
+            },
+        };
+    /**
+     * INVARIANTE 3: uma medição nova NÃO acorda um estado dormente. Só progresso acorda - senão
+     * rodar `sync` faria todo trabalho parado parecer vivo outra vez.
+     */
+    if (progressed)
+        return {
+            ...state,
+            status: "active",
+            evidenceSource: "measurement",
+            lastMeasuredAt: at,
+            lastProgressAt: at,
+            measuredDays: [],
+            lastVerdict: { state: "unmet", because: verdict.because },
+            by: by ?? state.by,
+            /** Um estado que estava órfão e voltou a ser mensurável perde a resolução antiga. */
+            ...(state.status === "orphaned" ? { resolution: undefined } : {}),
+        };
+    const days = state.measuredDays.includes(day(at))
+        ? state.measuredDays
+        : [...state.measuredDays, day(at)];
+    return {
+        ...state,
+        status: days.length >= dormantAfter
+            ? "dormant"
+            : state.status === "orphaned"
+                ? "active"
+                : state.status,
+        evidenceSource: "measurement",
+        lastMeasuredAt: at,
+        measuredDays: days,
+        lastVerdict: { state: "unmet", because: verdict.because },
+        by: by ?? state.by,
+        ...(state.status === "orphaned" ? { resolution: undefined } : {}),
+    };
+}
+/** A ÚNICA porta para `abandoned`, e ela é uma pessoa. */
+export function declareAbandoned(state, by, at, reason) {
+    return {
+        ...state,
+        status: "abandoned",
+        resolution: {
+            type: "abandoned",
+            source: "developer",
+            at,
+            ...(reason ? { reason } : {}),
+        },
+    };
+}
+/**
+ * COMO O RECALL FALA DE UM ESTADO - invariante 4.
+ *
+ * Um estado que o agente criou e que ninguém mediu é hipótese, e a frase tem que dizer isso. Um
+ * estado medido há seis dias é a última coisa que a gente sabe, não o que está acontecendo agora.
+ */
+export function authorityOf(state) {
+    if (state.createdBy === "agent" && state.evidenceSource === "none")
+        return {
+            authority: "hypothesis",
+            label: "hypothesis, written by an agent and never measured",
+        };
+    if (!state.lastMeasuredAt)
+        return { authority: "hypothesis", label: "declared, not measured yet" };
+    if (state.status === "orphaned")
+        return {
+            authority: "last-known",
+            label: `last known before it became unmeasurable on ${day(state.lastMeasuredAt)}`,
+        };
+    if (state.status === "dormant")
+        return {
+            authority: "last-known",
+            label: `no progress observed since ${state.lastProgressAt ? day(state.lastProgressAt) : day(state.createdAt)}`,
+        };
+    return {
+        authority: "confirmed",
+        label: `measured ${day(state.lastMeasuredAt)}`,
+    };
+}

package/dist/memory/write.js

@@ -0,0 +1,139 @@
+/**
+ * A FRONTEIRA DE ESCRITA, A METADE DO CLIENTE - onde o schema para de confiar no agente.
+ *
+ * O recall já está protegido; aqui o risco não é "a máquina de estados sabe o que fazer" e sim "o
+ * agente consegue inserir dado ruim pela porta". Um agente entusiasmado, um retry de rede ou uma
+ * compactação de conversa não podem contaminar a memória.
+ *
+ * ─────────────────────────────────────────────────────────────────────────
+ * O PIPELINE, e a ordem é a garantia
+ *
+ *     request -> validate -> normalize -> [fronteira] -> fingerprint -> deduplicate -> budget
+ *                                                                                   -> persist
+ *
+ * O QUE ESTE ARQUIVO FAZ TERMINA NA FRONTEIRA. Validar e normalizar são daqui porque a
+ * observabilidade de uma condição depende do censo, que está no disco dele - a plataforma não tem
+ * como saber se `Loader` é composto por alguém naquele repositório. Identidade, deduplicação,
+ * orçamento e persistência são do outro lado, porque dependem do estado e da sessão.
+ *
+ * O CLIENTE OBSERVA E TESTEMUNHA. A PLATAFORMA LEMBRA E DECIDE O EFEITO DA EVIDÊNCIA.
+ *
+ * ─────────────────────────────────────────────────────────────────────────
+ * O AGENTE NÃO FABRICA MEDIÇÃO
+ *
+ * `verdict`, `progress` e `snapshotId` estão em `DERIVED_FIELDS`: eles chegam pelo canal de medição
+ * (o `sync`/`doctor`, que roda o avaliador contra o censo), nunca por `remember`. Sem essa linha, um
+ * agente poderia escrever `verdict: "met"` e se conceder a autoridade de ter medido - a mesma
+ * escalada que `measured` como procedência já não permite.
+ */
+import { DECLARABLE, DERIVED_FIELDS, } from "./contract.js";
+import { validateCondition } from "./predicate.js";
+const squash = (v) => v.trim().replace(/\s+/g, " ");
+/** `Button`, `button` e ` Button ` são o mesmo sujeito - e a chave é o que o fingerprint verá. */
+const canonKey = (v) => squash(v)
+    .toLowerCase()
+    .replace(/[\s_]+/g, "-");
+const rejected = (reason, details) => ({
+    accepted: false,
+    reason,
+    details,
+});
+/**
+ * O SCHEMA É FECHADO, e campo que ninguém conhece é ERRO - nunca silêncio.
+ *
+ * Se amanhã um agente mandar `priority: "permanent"` e o servidor ignorar, ele segue acreditando que
+ * aquela semântica foi aceita. É a mesma filosofia do campo derivado: recusar em voz alta é a única
+ * resposta que não mente.
+ */
+const ALLOWED = {
+    decision: [
+        "kind",
+        "text",
+        "applies",
+        "ruleKind",
+        "when",
+        "family",
+        "tasks",
+        "subject",
+        "provenance",
+    ],
+    rationale: ["kind", "text", "subject", "provenance", "confirmation"],
+    "work-state": ["kind", "exit", "createdBy", "provenance"],
+};
+export function rejectDerived(payload) {
+    const sent = Object.keys(payload).filter((k) => DERIVED_FIELDS.includes(k));
+    return sent.length === 0
+        ? null
+        : rejected(sent.some((k) => k.startsWith("verdict") ||
+            k.startsWith("snapshot") ||
+            k === "progress")
+            ? "fabricated_verdict"
+            : "derived_field_supplied", `${sent.join(", ")} ${sent.length === 1 ? "is" : "are"} derived from measurement on our side - propose the fact, never its authority`);
+}
+export function rejectUnknown(payload) {
+    const kind = String(payload.kind ?? "");
+    const allowed = ALLOWED[kind];
+    if (!allowed)
+        return rejected("unknown_field", `"${kind || "(nothing)"}" is not a kind of memory this platform stores`);
+    const derived = rejectDerived(payload);
+    if (derived)
+        return derived;
+    const strange = Object.keys(payload).filter((k) => !allowed.includes(k));
+    return strange.length === 0
+        ? null
+        : rejected("unknown_field", `${strange.join(", ")} ${strange.length === 1 ? "is not a field" : "are not fields"} of a ${kind} - a field nobody reads would look accepted`);
+}
+/**
+ * VALIDAR E NORMALIZAR - e parar antes da identidade.
+ *
+ * O CLI não sabe quem é o usuário: as credenciais guardam um token, não um id. E isso não é uma
+ * limitação a contornar, é a regra deste desenho: a identidade só pode ser fechada no primeiro lugar
+ * que tem tudo para prová-la.
+ */
+export function prepareWrite(m, obs) {
+    if (!DECLARABLE.includes(m.provenance))
+        return rejected("invalid_provenance", `"${m.provenance}" is not something an agent can claim - measurement is conferred by whoever measures`);
+    if (m.kind !== "work-state") {
+        if (!squash(m.text))
+            return rejected("empty_text", "a memory with no text says nothing");
+        /**
+         * `rationale` FALA DO QUE NÃO ESTÁ NO CÓDIGO, então nenhuma medição pode confirmá-lo nem
+         * desmenti-lo - ele nunca decai. Por isso ele não nasce de inferência: o agente PROPÕE, e uma
+         * pessoa confirma. Sem esta linha, dois anos de "parece que vocês evitam X" seriam tratados
+         * como conhecimento atual.
+         */
+        if (m.kind === "rationale" && m.provenance === "agent_inferred")
+            return rejected("inferred_rationale_not_allowed", "a rationale never starts as inference - propose it and let a person confirm");
+    }
+    if (m.kind === "work-state") {
+        const check = validateCondition(m.exit, obs);
+        if (!check.ok) {
+            /**
+             * O MOTIVO DA RECUSA É TRADUZIDO PARA O ENUM, porque o agente do outro lado precisa de um
+             * código - não de uma frase que pode mudar de redação.
+             */
+            const reason = check.because.includes("reference_replaced")
+                ? "weak_migration_predicate"
+                : check.because.includes("cannot be observed") ||
+                    check.because.includes("no readable recipe")
+                    ? "unobservable_subject"
+                    : "invalid_condition";
+            return rejected(reason, check.because);
+        }
+    }
+    const subject = m.kind === "work-state" ? m.exit.subject : m.subject;
+    return {
+        ok: true,
+        draft: {
+            kind: m.kind,
+            ...(subject ? { subject: squash(subject) } : {}),
+            key: subject ? canonKey(subject) : "",
+            ...(m.kind === "work-state"
+                ? { exit: m.exit }
+                : { text: squash(m.text) }),
+            applies: m.kind === "decision" ? m.applies.map(squash) : [],
+            ...(m.kind === "decision" ? { ruleKind: m.ruleKind } : {}),
+            provenance: m.provenance,
+        },
+    };
+}

package/dist/naming-queue.js

@@ -0,0 +1,56 @@
+import { anatomyFromSketch } from "./anatomy-from-sketch.js";
+/** O nó que a derivação não soube nomear. `box` é o último recurso dela. */
+const UNNAMED = "box";
+function walk(read, onNode) {
+    for (const node of read) {
+        onNode(node);
+        if (Array.isArray(node.children) && node.children.length > 0)
+            walk(node.children, onNode);
+    }
+}
+/**
+ * A fila, derivada dos mesmos insumos que o envio usa.
+ *
+ * `defines` e `versionOf` entram porque a derivação os usa para distinguir um componente DELES de
+ * uma peça de terceiro, e um nó que vira `component` ou `external` é um nó nomeado: computar a fila
+ * sem eles a inflaria com trabalho que não existe.
+ */
+export function namingQueue(looks, defines, versionOf) {
+    const pending = [];
+    let components = 0;
+    let nodes = 0;
+    let named = 0;
+    let settled = 0;
+    for (const component of Object.keys(looks)) {
+        const sketch = looks[component]?.sketch;
+        if (!Array.isArray(sketch) || sketch.length === 0)
+            continue;
+        const derived = anatomyFromSketch(sketch, defines, versionOf);
+        if (derived.read.length === 0)
+            continue;
+        components += 1;
+        const unnamed = [];
+        walk(derived.read, (node) => {
+            nodes += 1;
+            if (node.name !== UNNAMED) {
+                named += 1;
+                return;
+            }
+            const at = node.at;
+            if (typeof at !== "number")
+                return;
+            const raw = sketch[at];
+            unnamed.push({
+                tag: raw?.tag ?? "div",
+                at,
+                ...(raw?.classes ? { classes: raw.classes } : {}),
+            });
+        });
+        if (unnamed.length === 0) {
+            settled += 1;
+            continue;
+        }
+        pending.push({ component, nodes: unnamed });
+    }
+    return { components, nodes, named, settled, pending };
+}

package/package.json

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