synthesisui 0.16.102 → 0.16.104

package/dist/commands/import.js

@@ -636,6 +636,21 @@ export async function takeCensus(root, opts) {
             }
             usageSeen.add(rel);
             usageProgress?.step(rel);
+            /**
+             * THE THEME IS SWITCHED WHERE THE APP IS, and this loop was walking right
+             * past the file that says so. Measured on a real monorepo (dono, 02/08):
+             * `packages/ui` declares 346 dark utilities across 58 files and NONE of the
+             * four switch fields; `apps/web-dashboard` declares `data-theme`,
+             * `defaultTheme="dark"`, `enableSystem={false}` and an `<html>` carrying both
+             * - so "which face does it open in" was unanswerable from the census and cost
+             * a hand read of a file this loop already had open.
+             *
+             * The scope is read first and wins on every field, so this only fills what a
+             * library legitimately does not have - and the label is recorded, because the
+             * system being measured here and the theme being switched there are two facts,
+             * not one average.
+             */
+            readSignalsInto(signals, importTally, rel, src, u.label);
             scanComponentsInto(usageTally, rel, src, [...shared, ...uInternal]);
             // WHERE THE PAIRS LIVE. A library composes almost none of itself inside
             // itself - `Button` goes inside `Modal` in the APP, not in the library
@@ -1645,8 +1660,21 @@ function rootPackage(tag, sketch) {
         : {};
 }
 async function resolveReadParts(census, root) {
-    const read = census.reading?.components;
-    if (!read)
+    /**
+     * A READING IS OPTIONAL HERE. THE SKETCH IS NOT.
+     *
+     * This returned on line one when nobody had authored a reading, and a DERIVED
+     * anatomy needs no reading at all - so the deriver shipped and never ran on the
+     * path the owner actually uses. Measured on his own re-import (02/08): the census
+     * carried `rootFrom` on 13 looks and `from` on 162 sketch nodes - the new fields
+     * arrived - and `tree` on 0 of 36. Two components then read as empty contracts
+     * and came back below the floor.
+     *
+     * "Medido 100%, convertido 0%", one week after the law that names it. The guard
+     * is now about having something to convert, not about who asked.
+     */
+    const read = census.reading?.components ?? {};
+    if (!census.looks || Object.keys(census.looks).length === 0)
         return;
     const declared = new Map(Object.entries(census.declared));
     // The manifest is read ONCE for the whole run: the version belongs in a rule's
@@ -1774,10 +1802,14 @@ async function resolveReadParts(census, root) {
         for (const n of resolved.notes)
             notes.add(n);
     }
-    const total = Object.keys(read).length;
+    const authored = Object.keys(read).length;
+    const total = authored || Object.keys(census.looks ?? {}).length;
     if (named > 0 || shaped > 0) {
         console.log("");
-        console.log(body(`${named} part${named === 1 ? "" : "s"} your reading named across ${total} component${total === 1 ? "" : "s"} - each previews as what it IS rather than as a text box`));
+        console.log(body(
+        // "Your reading" only when there WAS one - otherwise the names came off
+        // their own markup, and claiming otherwise credits somebody's absent work.
+        `${named} part${named === 1 ? "" : "s"} named across ${total} component${total === 1 ? "" : "s"}${authored > 0 ? " - your reading and their markup" : " - read off their own markup"}, so each previews as what it IS rather than as a text box`));
     }
     if (shaped > 0) {
         console.log(body(`${shaped} of them arrived with a SHAPE - the parts nested as they nest in your code, so the preview is the component and not a row of labels`));
@@ -1889,6 +1921,20 @@ export async function runImport(opts) {
         if (scope)
             census.scope = scope;
     }
+    /**
+     * DERIVE THE ANATOMY ON THE MEASURING PATH TOO.
+     *
+     * The send path resolves the reading above; a plain `--dry` measure never
+     * reached that function, so the census on disk - the file the skill reads to
+     * author its reading, and the file every one of our real-repo specs reads -
+     * carried a sketch for every component and a tree for none. The person's own
+     * re-import proved it: 36 sketches, 162 stamped nodes, 0 trees (dono, 02/08).
+     *
+     * Written into the census means the skill sees the shape it would otherwise
+     * have to author from scratch, and can spend its judgement on the names.
+     */
+    if (!opts.census)
+        await resolveReadParts(census, root);
     summarize(census);
     // Only when nobody has scoped yet. Telling someone to scope to the folder
     // they just scoped to reads as the tool not having noticed.

package/dist/doctor/signals.js

@@ -75,6 +75,7 @@ export function emptySignals() {
             enableSystem: null,
             prefersColorScheme: 0,
             htmlCarries: [],
+            switchedIn: null,
             page: [],
         },
         libraries: [],
@@ -113,7 +114,13 @@ export function libraryOf(specifier) {
  * Fold one file into the signals. Called from the walk the census already does, so nothing
  * here costs a second pass over the disk.
  */
-export function readSignalsInto(into, imports, file, source) {
+export function readSignalsInto(into, imports, file, source, 
+/**
+ * WHERE THIS FILE IS, when it is not the system's own folder - the `--usage`
+ * label. Present means "read for evidence", and the only thing it changes is
+ * that a switch found here is RECORDED AS FOUND HERE. See `switchedIn`.
+ */
+from) {
     const isCode = /\.(tsx|jsx|ts|js|mjs|cjs|vue|svelte)$/i.test(file);
     const isStyle = /\.(css|scss|sass|less)$/i.test(file);
     if (isStyle) {
@@ -146,6 +153,16 @@ export function readSignalsInto(into, imports, file, source) {
             }
         }
     }
+    /**
+     * THE SCOPE WINS, ALWAYS - `??=` is the whole rule. The system's own folder is
+     * read first, so a switch it declares is never overwritten by an app's; an app
+     * only fills what was null, which is the four fields a library legitimately does
+     * not have.
+     */
+    const before = into.theme.attribute === null &&
+        into.theme.defaultTheme === null &&
+        into.theme.enableSystem === null &&
+        into.theme.htmlCarries.length === 0;
     into.theme.attribute ??= THEME_ATTRIBUTE.exec(source)?.[1] ?? null;
     into.theme.defaultTheme ??= DEFAULT_THEME.exec(source)?.[1] ?? null;
     if (into.theme.enableSystem === null) {
@@ -160,12 +177,42 @@ export function readSignalsInto(into, imports, file, source) {
      */
     const html = HTML_ATTRS.exec(source);
     if (html) {
-        for (const m of html[1].matchAll(/([a-zA-Z-]+)\s*=\s*(?:["']([^"']*)["']|\{["']([^"']*)["']\})/g)) {
-            const attr = `${m[1]}="${m[2] ?? m[3] ?? ""}"`;
+        const carry = (attr) => {
             if (!into.theme.htmlCarries.includes(attr)) {
                 into.theme.htmlCarries.push(attr);
             }
+        };
+        for (const m of html[1].matchAll(/([a-zA-Z-]+)\s*=\s*(?:["']([^"']*)["']|\{["']([^"']*)["']\})/g)) {
+            carry(`${m[1]}="${m[2] ?? m[3] ?? ""}"`);
         }
+        /**
+         * `style={{ colorScheme: "dark" }}` - the SECOND thing that decides what a dark
+         * rule matches, and the attribute pass above cannot see it: its value is not a
+         * quoted string sitting after an `=`, it is a property inside an object.
+         *
+         * It is on the owner's own root layout, right beside the `data-theme` the pass
+         * DID read, and it is what tells the browser which face to paint its own
+         * widgets - a scrollbar and a form control follow `color-scheme`, not a class
+         * (dono, 02/08).
+         */
+        const scheme = /\bcolorScheme\s*:\s*["']([^"']+)["']/.exec(html[1]);
+        if (scheme)
+            carry(`colorScheme="${scheme[1]}"`);
+    }
+    /**
+     * WHOSE FILE ANSWERED IT. Stamped only when the switch was null before this file
+     * and is not null after, so the label names the file's ROOT that actually
+     * supplied it - and only for a `--usage` root, because the scope needs no
+     * attribution: it is the system by definition.
+     */
+    if (from &&
+        into.theme.switchedIn === null &&
+        before &&
+        (into.theme.attribute !== null ||
+            into.theme.defaultTheme !== null ||
+            into.theme.enableSystem !== null ||
+            into.theme.htmlCarries.length > 0)) {
+        into.theme.switchedIn = from;
     }
     /**
      * THE PAGE PAINTS, from the markup. A `min-h-screen` container with a background is
@@ -310,6 +357,15 @@ export function describeSignals(s) {
             bits.push("with the OS allowed a vote");
         out.push(`${bits.join(", ")}.`);
     }
+    /**
+     * TWO PLACES, TWO FACTS. A library that declares 346 dark utilities and no
+     * switch is not a library missing something - the switch belongs to the app that
+     * mounts it. Saying WHERE keeps the sentence true and stops the reader from
+     * concluding the system declares a provider it does not have.
+     */
+    if (t.switchedIn) {
+        out.push(`the system is measured where you scoped it; the theme is switched in \`${t.switchedIn}\` - that is where the attribute, the default and the \`<html>\` came from.`);
+    }
     if (t.htmlCarries.length > 0) {
         out.push(`\`<html>\` carries ${t.htmlCarries.map((a) => `\`${a}\``).join(" ")} - which is the ancestor every dark rule of theirs matches, and therefore the one ours must match.`);
     }

package/dist/doctor/sketch.js

@@ -23,6 +23,50 @@ import { importMap, packageOfTag } from "./imports.js";
 import { definitionSpan } from "./transcribe.js";
 /** `{children}` / `{props.children}` - the caller's content, spelled either way. */
 const CHILDREN = /\{\s*(?:props\.)?children\s*\}/;
+/**
+ * THE TEXT THAT SITS DIRECTLY INSIDE ONE ELEMENT - its own gaps, not its
+ * children's contents.
+ *
+ * The first version of the slot check read only the span between an element's
+ * open tag and the next tag of any kind, so it saw `{children}` only when it was
+ * the FIRST thing inside. A real panel renders a header and THEN the caller's
+ * content, which is the mixed case the reader has a form for - and it was
+ * invisible. Found by driving `runImport` over a Base-UI dialog whose `{children}`
+ * follows its close button (02/08).
+ *
+ * Attribution matters as much as detection: `{children}` inside a CHILD is that
+ * child's slot, so the walk collects the gaps at this element's own level and
+ * skips whole subtrees.
+ */
+function directText(source, events, index) {
+    const open = events[index];
+    const openEnd = source.indexOf(">", open.at);
+    if (openEnd === -1)
+        return "";
+    let from = openEnd + 1;
+    const gaps = [];
+    let rel = 0;
+    for (let j = index + 1; j < events.length; j++) {
+        const event = events[j];
+        if (event.kind === "open") {
+            if (rel === 0)
+                gaps.push(source.slice(from, event.at));
+            rel += 1;
+            continue;
+        }
+        rel -= 1;
+        // Our own close: the last gap runs up to it, and the element ends here.
+        if (rel < 0) {
+            gaps.push(source.slice(from, event.at));
+            break;
+        }
+        if (rel === 0) {
+            const closeEnd = source.indexOf(">", event.at);
+            from = closeEnd === -1 ? event.at : closeEnd + 1;
+        }
+    }
+    return gaps.join(" ");
+}
 /**
  * Past this a component is a page in disguise, and the gate already said no.
  *
@@ -177,10 +221,12 @@ export function sketchOf(source, name) {
                 !between.includes("<")) {
                 node.text = between;
             }
-            // The caller's content, as a fact - see `SketchNode.slot`.
-            if (CHILDREN.test(between))
-                node.slot = true;
         }
+        // The caller's content, as a fact - see `SketchNode.slot`. Read from the
+        // element's DIRECT text, so a `{children}` after a header still counts and one
+        // inside a child belongs to that child.
+        if (CHILDREN.test(directText(source, events, i)))
+            node.slot = true;
         out.push(node);
         depth += 1;
     }

package/dist/skill-import.js

@@ -148,11 +148,11 @@ file to pick between. Nothing is sent by \`--dry\`. Read the file.
 ### 2. Walk them through the decisions - ALL of them, before any reading
 
 **Every question this skill asks is answerable from the census you just took.** Source, name,
-primary, theme, canvas, our-kit-or-theirs, architecture - the numbers behind all seven are in
-the file on their disk, and none of them needs the anatomy.
+primary, theme, canvas, architecture - the numbers behind all six are in the file on their disk,
+and none of them needs the anatomy.
 
 They used to be asked AFTER the reading, and that put six hundred lines of work between the
-person's first answer and their second (dono, 01/08). A person who answers seven questions in
+person's first answer and their second (dono, 01/08). A person who answers six questions in
 ninety seconds and then watches a bar has had a good four minutes; the same person interrupted
 twice in the middle of a silence has had a bad twenty.
 
@@ -160,7 +160,7 @@ So: ask everything here, in one pass, and **do not come back**. If something you
 the reading contradicts an answer, you do not reopen the question - you say so in the report at
 the end and let them change it there.
 
-Seven decisions are theirs. **Ask them as separate questions with selectable options** - use your
+Six decisions are theirs. **Ask them as separate questions with selectable options** - use your
 question tool, one call per decision, so they pick instead of reading a wall and composing a
 reply. A single block containing everything is a report, and a report gets read, not answered.
 
@@ -244,35 +244,37 @@ canvas  #222326  darkgray-500 - what DashboardLayout paints on <main>
 Say it and let them object. Offering five near-blacks to pick between is asking someone to
 re-decide something their code already decided.
 
-**2f. Our kit, or theirs alone** - ask this ONLY when they already have a component library,
-which is when \`--scope\` pointed at one and the CLI said so. An app with no components of its own
-has nothing to weigh and should never see the question.
+**2f. Our kit** - do not ask. A project that already has a component library gets **theirs
+alone**, and you say so in one line:
 
 \`\`\`
-Every system born here comes with 45 components of ours - button, card, input,
-table, the rest of a working toolkit. You already have 37.
-
-  add ours to yours (recommended)   68 components, and the 23 governed by your
-                                    own rules are the 23 you wrote
-  mine alone                        37 components, all of them yours. Our
-                                    layouts that need a component you do not
-                                    have stay out too. Add any of ours later
-                                    from the library, one at a time
+This system is yours alone - the 37 components you wrote, and none of ours.
+Add any of ours later from the library, one at a time.
 \`\`\`
 
-Send it as \`"standards": "none"\` in the reading when they choose the second, and leave the field
-out when they choose the first. **Recommend adding ours**, and say why in one line: a component of
-ours costs nothing until something composes it, and having a \`table\` the day somebody needs a
-table is worth more than a shorter list.
+Send it as \`"standards": "none"\` in the reading. Every time, with one exception below.
+
+**Why this stopped being a question.** Somebody who points us at their own library is telling us
+what their system is, and 45 components of ours landing beside 37 of theirs makes a system of 82
+where only 37 are governed by anything they wrote - the number on their own screen stops being
+about them. The kit is one click away in the library afterwards, so choosing wrong here costs a
+click and choosing to ask costs a pause in the middle of their import.
+
+**The exception, and it is not a preference.** An app with NO components of its own - \`--scope\`
+pointed at an app rather than a library, and the CLI reported no component library - must NOT get
+\`"standards": "none"\`: theirs alone plus nothing of theirs is a system with zero components. Leave
+the field out there, exactly as before.
 
 Two things to be straight about, because both are true and neither is obvious:
 
-- **the foundations come from the seed either way.** Their palette, their scales, their type - all
+- **the foundations still come from the seed.** Their palette, their scales, their type - all
   theirs - but the seven type slots, the easing and the neutral floor arrive from ours, because
   the alternative to a type scale is no components at all rather than their components.
 - **our layouts are written in our recipes.** A landing that composes \`button\`, \`card\` and
-  \`badge\` needs those to exist. Choosing *mine alone* keeps the layouts whose recipes they
-  happen to have and drops the rest - a layout pointing at a recipe nobody has renders as holes.
+  \`badge\` needs those to exist. Theirs alone keeps the layouts whose recipes they happen to have
+  and drops the rest - a layout pointing at a recipe nobody has renders as holes. Say that number
+  when the CLI reports it, so a shorter list of layouts is a fact they were told rather than one
+  they discover.
 
 **2g. Which architecture has priority** - ask only when the CLI reported more than
 one, which it does under "How this project is organised".
@@ -329,6 +331,13 @@ census carries is the failure this pipeline keeps paying for. The sketch now run
 so a big component arrives WHOLE: \`TextEditor\` used to lose its editable region at node 60 and
 that single truncation is what forced a hand-read of the file (dono, 01/08).
 
+\`signals.theme\` includes the SWITCH - \`attribute\`, \`defaultTheme\`, \`enableSystem\` and what
+\`<html>\` carries, \`colorScheme\` included - read from the \`--usage\` roots as well as the scope,
+because a component library declares the dark utilities and the APP declares the switch. When it
+came from an app, \`switchedIn\` names which one: say "the system is measured in \`packages/ui\`, the
+theme is switched in \`apps/web-dashboard\`" rather than reporting that the library declares a
+provider it does not have. Answering 2d never needs a layout file opened.
+
 **Validate in ONE call, at the end.** Build every recipe in memory first, then send them all to
 \`validate_recipes\` - one round trip for the whole reading instead of one per component. A reader
 with 35 anatomies spent 35 turns asking the same question, and none of that was thinking. Only

package/package.json

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