synthesisui 0.16.102 → 0.16.103

package/dist/commands/import.js

@@ -1645,8 +1645,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 +1787,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 +1906,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/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".

package/package.json

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