@squinch/core 0.1.1 → 0.3.0

package/dist/api.d.ts

@@ -36,6 +36,17 @@ export declare function iconsUsedBy(files: ProjectFile[] | string): {
  *  them and a result of only `azure/key-vaults` reads as proof that
  *  `azure/key-vault` doesn't exist) can look them up via `packInfo`. */
 export declare function searchIcons(query: string, pack?: string): string[];
+/** The same search, saying how it matched. `relaxed: true` means no icon
+ *  matched every word, so the hits are the closest partial matches instead —
+ *  callers that print for an agent loop label them (`no exact match —
+ *  closest:`), because near-misses answer the question and an empty list
+ *  forces a second pass with different words. Measured before ranking
+ *  existed: `rag` returned eighteen sto*rag*e rows with `sys/rag` dead last,
+ *  and "message queue" / "object storage" returned nothing at all. */
+export declare function searchIconsDetailed(query: string, pack?: string): {
+    hits: string[];
+    relaxed: boolean;
+};
 export type { ProjectFile };
 export type * from "./model/types.js";
 export { HUES } from "./model/types.js";

package/dist/api.js

@@ -69,6 +69,16 @@ export function iconsUsedBy(files) {
  *  them and a result of only `azure/key-vaults` reads as proof that
  *  `azure/key-vault` doesn't exist) can look them up via `packInfo`. */
 export function searchIcons(query, pack) {
+    return searchIconsDetailed(query, pack).hits;
+}
+/** The same search, saying how it matched. `relaxed: true` means no icon
+ *  matched every word, so the hits are the closest partial matches instead —
+ *  callers that print for an agent loop label them (`no exact match —
+ *  closest:`), because near-misses answer the question and an empty list
+ *  forces a second pass with different words. Measured before ranking
+ *  existed: `rag` returned eighteen sto*rag*e rows with `sys/rag` dead last,
+ *  and "message queue" / "object storage" returned nothing at all. */
+export function searchIconsDetailed(query, pack) {
     // Vendors are inconsistent about number — Azure has "Container Registries"
     // and "Data Factories" where everyone searches "container registry" and
     // "data factory" — so both sides are singularized before comparing.
@@ -97,20 +107,46 @@ export function searchIcons(query, pack) {
         }
     }
     const words = rawWords.map(stem);
-    const hits = [];
+    const joined = words.join(" ");
+    const scored = [];
     for (const name of allPackNames()) {
         if (packFilter && name !== packFilter)
             continue;
-        const aliases = packInfo(name)?.aliases ?? {};
         const haystack = (id) => norm(`${id} ${iconTitle(name, id) ?? ""}`);
-        const matched = new Set(iconIds(name).filter((id) => words.every((w) => haystack(id).includes(w))));
-        for (const id of [...matched].sort()) {
-            if (aliases[id] && matched.has(aliases[id]))
-                continue; // canonical covers it
-            hits.push(`${name}/${id}`);
+        const matchedIds = new Set(iconIds(name).filter((id) => words.some((w) => haystack(id).includes(w)) || !words.length));
+        for (const id of matchedIds) {
+            const hay = haystack(id);
+            const hayWords = new Set(hay.split(" "));
+            scored.push({
+                hit: `${name}/${id}`,
+                exact: joined && norm(id) === joined ? 1 : 0,
+                whole: words.length && words.every((w) => hayWords.has(w)) ? 1 : 0,
+                matched: words.filter((w) => hay.includes(w)).length,
+            });
         }
     }
-    return hits.sort();
+    // One row per icon: an alias row is dropped only when its canonical is in
+    // the SAME result list. Checking the broader matched set instead deduped
+    // `sys/vector-search` (a full match) against a canonical that had only
+    // matched one word and was not being returned at all.
+    const dedupe = (list) => {
+        const present = new Set(list.map((s) => s.hit));
+        return list.filter((s) => {
+            const name = s.hit.slice(0, s.hit.indexOf("/"));
+            const id = s.hit.slice(s.hit.indexOf("/") + 1);
+            const canonical = (packInfo(name)?.aliases ?? {})[id];
+            return !(canonical && present.has(`${name}/${canonical}`)); // canonical covers it
+        });
+    };
+    const rank = (list) => dedupe(list)
+        .sort((a, b) => b.exact - a.exact || b.whole - a.whole || b.matched - a.matched || (a.hit < b.hit ? -1 : 1))
+        .map((s) => s.hit);
+    const full = scored.filter((s) => s.matched === words.length);
+    if (full.length || !words.length)
+        return { hits: rank(full), relaxed: false };
+    // Nothing matched every word: fall back to partial matches, best first.
+    // Capped — the point is a next move, not a directory listing.
+    return { hits: rank(scored).slice(0, 12), relaxed: true };
 }
 // the one colour vocabulary, for editors that complete it and tests that sweep it
 export { HUES } from "./model/types.js";

package/dist/layout/layout.js

@@ -405,34 +405,24 @@ export async function layoutView(model, view, font = INTER) {
     // ── edge classes: inner (same entity) | coplanar (same rank, both bare) |
     //    cross-rank (ELK's) ────────────────────────────────────────────────────
     const inner = (e) => entityOf(e.from) === entityOf(e.to) && byPath.get(e.from)?.frame;
-    // The coplanar router handles bare leaves, leaves inside expanded frames,
-    // and expanded frames themselves — a framed endpoint routes wall-to-wall
-    // between the outermost frame rects (docs/notes/coplanar.md, approach #5).
-    // Zone units stay out: a zone lays out as one block and its dashed boundary
-    // is not a wall a wire can enter, so those edges go to ELK with the warning
-    // below. Classifying an edge coplanar (hiding it from ELK) IS the entire
-    // same-rank mechanism — there is no other way to co-layer its units.
+    // The coplanar router handles bare leaves and leaves inside any unit — an
+    // expanded frame or a zone — plus frames named as endpoints. A unit endpoint
+    // routes between the two *outermost* unit rects, then inward to the leaf
+    // when the corridor is clear (docs/notes/coplanar.md, approaches #5 and #6).
+    // Zones used to be turned away on the grounds that a dashed boundary is not
+    // a wall a wire can enter; ELK's own wires enter zones constantly, and the
+    // first real diagram that banded two namespaces on one row (lookbook 27-k8s)
+    // fell apart on that rule. Classifying an edge coplanar (hiding it from ELK)
+    // IS the entire same-rank mechanism — there is no other way to co-layer its
+    // units.
     const framePathSet = new Set(graph.frames.map((f) => f.path));
     const routable = (p) => byPath.has(p) || framePathSet.has(p);
     const coplanar = edges.filter((e) => !inner(e) &&
         routable(e.from) &&
         routable(e.to) &&
-        !outerZoneOf(entityOf(e.from)) &&
-        !outerZoneOf(entityOf(e.to)) &&
         unitOf(e.from) !== unitOf(e.to) &&
         rank.get(unitOf(e.from)) === rank.get(unitOf(e.to)));
     const coplanarSet = new Set(coplanar.map((e) => e.id));
-    for (const e of edges) {
-        if (!inner(e) && !coplanarSet.has(e.id) &&
-            unitOf(e.from) !== unitOf(e.to) &&
-            rank.get(unitOf(e.from)) === rank.get(unitOf(e.to)))
-            diagnostics.push({
-                severity: "warning",
-                message: `same-rank edge ${e.from} → ${e.to} involves a zone — the router cannot cross a zone boundary, so the row may not hold`,
-                fix: `give the zone its own band in \`rows\`, or drop one end from the zone`,
-                loc: view.loc,
-            });
-    }
     const elkEdges = edges.filter((e) => !coplanarSet.has(e.id));
     const natural = new Map(units.map((p) => [p, 0]));
     for (let i = 0; i < units.length; i++)
@@ -725,6 +715,12 @@ export async function layoutView(model, view, font = INTER) {
             // wrong. DESIGN §2's rule is about numbers chosen from a deliberate
             // scale, not arithmetic for its own sake, and this pair is the scale.
             "elk.padding": "[top=28,left=20,bottom=20,right=20]",
+            // a labelled zone-coplanar edge widens the gutter to its pill, exactly
+            // as entityElk does for frames — a zone is a unit, and the reservation
+            // is keyed by unit
+            ...(coplanarGutter.get(z.id)
+                ? { "elk.spacing.individual": `elk.spacing.nodeNode:${coplanarGutter.get(z.id)}` }
+                : {}),
             "elk.spacing.nodeNode": String(SP[0]),
             "elk.layered.spacing.nodeNodeBetweenLayers": hasElkLabels ? String(LABEL_GAP) : String(SP[1]),
             // see entityElk: ELK does not inherit edge spacing into a compound
@@ -962,9 +958,9 @@ export async function layoutView(model, view, font = INTER) {
     };
     const frameByPath = new Map(frames.map((f) => [f.path, f]));
     const zoneRectById = new Map(pZones.map((z) => [z.id, { path: z.id, ...z }]));
-    // a frame is its own unit, so try the frame rect first — the leaf branch is
-    // only for endpoints that are genuinely bare nodes
-    const routeRect = (p) => frameByPath.get(unitOf(p)) ?? nodeById.get(p);
+    // a frame or zone is its own unit, so try those rects first — the leaf
+    // branch is only for endpoints that are genuinely bare nodes
+    const routeRect = (p) => frameByPath.get(unitOf(p)) ?? zoneRectById.get(unitOf(p)) ?? nodeById.get(p);
     /** Every unit's rect on a rank — the obstacle set for blockedness. Unlike
      *  the old leaf-only scan this sees frames and zones too, so a coplanar
      *  wire no longer threads straight through a boundary it never noticed. */
@@ -1007,19 +1003,48 @@ export async function layoutView(model, view, font = INTER) {
         const b = routeRect(e.to);
         const blocked = blockedBy(e, a, b);
         const midCross = (n) => n[cross] + Math.round(n[crossSize] / 2);
-        /** The cross-coordinate the wire wants at an endpoint. A framed leaf pulls
-         *  the wire to its own height so the wall entry sits beside it — clamped
-         *  into the pair's shared cross-overlap band, because frames on one layer
-         *  are top-aligned with unequal sizes and an unclamped anchor could miss
-         *  the other rect entirely. */
-        const wantCross = (p, own, other) => {
+        /** The cross-coordinate the wire wants at an endpoint: the interior leaf's
+         *  own height, so the entry sits beside it, clamped into its unit's rect.
+         *  Approach #5 clamped into the pair's *shared* band so a straight run could
+         *  not miss the other rect; the jog handles any pair of heights, and the
+         *  shared clamp is what parked an entry away from a low leaf and stopped
+         *  the corridor below from ever reaching it. */
+        const wantCross = (p, own) => {
             const leaf = byPath.has(p) ? nodeById.get(p) : undefined;
             const raw = leaf ? midCross(leaf) : midCross(own);
-            const lo = Math.max(own[cross], other[cross]) + 12;
-            const hi = Math.min(own[cross] + own[crossSize], other[cross] + other[crossSize]) - 12;
-            if (lo > hi)
-                return NaN; // no shared band — shelf territory
-            return Math.min(Math.max(raw, lo), hi);
+            return Math.min(Math.max(raw, own[cross] + 12), own[cross] + own[crossSize] - 12);
+        };
+        /** Approach #6: walk a unit-wall entry inward to the leaf's own wall when
+         *  the straight corridor between them is provably empty — no node but the
+         *  leaf, no frame that does not enclose it, ±16 on the cross axis. Zone
+         *  boundaries are not obstacles; ELK's wires cross them too. The port then
+         *  sits on the leaf's face, so parallel wires spread *there* rather than
+         *  converging on one point after the wall. Anything else keeps the wall as
+         *  the end, exactly as approach #5 drew it — the wire never jogs inside a
+         *  compound, that interior is ELK's. */
+        const inward = (p, unit, side, want) => {
+            const wallOf = (r) => (side === highSide ? r[along] + r[alongSize] : r[along]);
+            const atWall = () => {
+                const c = freePort(unit, side, want);
+                return { c, end: pt(wallOf(unit), c), node: unit.path };
+            };
+            const leaf = byPath.has(p) ? nodeById.get(p) : undefined;
+            if (!leaf || leaf.path === unit.path)
+                return atWall();
+            const lo = Math.min(wallOf(unit), wallOf(leaf)), hi = Math.max(wallOf(unit), wallOf(leaf));
+            const clear = (c) => {
+                if (c < leaf[cross] + 8 || c > leaf[cross] + leaf[crossSize] - 8)
+                    return false;
+                const hit = (r) => r[along] < hi && r[along] + r[alongSize] > lo && r[cross] - 16 < c && r[cross] + r[crossSize] + 16 > c;
+                return (!nodes.some((n) => n.path !== leaf.path && hit(n)) &&
+                    !frames.some((f) => !leaf.path.startsWith(`${f.path}.`) && hit(f)));
+            };
+            if (!clear(want))
+                return atWall();
+            const c = freePort(leaf, side, want);
+            if (!clear(c))
+                return atWall();
+            return { c, end: pt(wallOf(leaf), c), node: leaf.path };
         };
         const carry = { label: e.label, async: e.async, animate: e.animate, style: e.style, count: e.count, tags: e.tags, color: e.color, heads: e.heads };
         // The router owns coplanar geometry, so it reserves and reports
@@ -1055,27 +1080,28 @@ export async function layoutView(model, view, font = INTER) {
             ports.push({ edge: e.id, node: a.path, side: first ? highSide : lowSide, x: pts[0].x, y: pts[0].y }, { edge: e.id, node: b.path, side: first ? lowSide : highSide, x: pts[1].x, y: pts[1].y });
             return { id: e.id, from: e.from, to: e.to, ...carry, points: pts, labelRect, coplanar: true };
         }
-        const aWant = wantCross(e.from, a, b);
-        const bWant = wantCross(e.to, b, a);
-        if (!blocked && !Number.isNaN(aWant) && !Number.isNaN(bWant)) {
+        if (!blocked) {
             const first = a[along] <= b[along];
             const [aSide, bSide] = first ? [highSide, lowSide] : [lowSide, highSide];
-            // freePort spreads parallel wall entries 16 apart; when both entries
-            // stay put and agree, the run is straight — otherwise it jogs at
-            // mid-gutter, which also gives every stub gutter/2 ≥ 24 of clearance
-            const aC = freePort(a, aSide, aWant);
-            const bC = freePort(b, bSide, bWant);
+            // freePort spreads parallel entries 16 apart on whichever face the wire
+            // ends on; when both entries stay put and agree, the run is straight —
+            // otherwise it jogs at mid-gutter, which also gives every stub
+            // gutter/2 ≥ 24 of clearance. The pill always sits on the gutter run,
+            // between the two unit walls, whether or not the ends reached inward.
+            const ia = inward(e.from, a, aSide, wantCross(e.from, a));
+            const ib = inward(e.to, b, bSide, wantCross(e.to, b));
+            const [aC, bC] = [ia.c, ib.c];
             const aWall = first ? a[along] + a[alongSize] : a[along];
             const bWall = first ? b[along] : b[along] + b[alongSize];
             if (aC === bC) {
-                const pts = [pt(aWall, aC), pt(bWall, aC)];
+                const pts = [ia.end, ib.end];
                 const labelRect = rectOnRun(Math.min(aWall, bWall), Math.max(aWall, bWall), aC);
-                ports.push({ edge: e.id, node: a.path, side: aSide, x: pts[0].x, y: pts[0].y }, { edge: e.id, node: b.path, side: bSide, x: pts[1].x, y: pts[1].y });
+                ports.push({ edge: e.id, node: ia.node, side: aSide, x: pts[0].x, y: pts[0].y }, { edge: e.id, node: ib.node, side: bSide, x: pts[1].x, y: pts[1].y });
                 return { id: e.id, from: e.from, to: e.to, ...carry, points: pts, labelRect, coplanar: true };
             }
             // jog: 4-point Z at mid-gutter — the pill sits on the crossing segment
             const mid = Math.round((Math.min(aWall, bWall) + Math.max(aWall, bWall)) / 2);
-            const pts = [pt(aWall, aC), pt(mid, aC), pt(mid, bC), pt(bWall, bC)];
+            const pts = [ia.end, pt(mid, aC), pt(mid, bC), ib.end];
             const labelRect = e.label
                 ? (() => {
                     const bw = badgeW(e.id);
@@ -1085,7 +1111,7 @@ export async function layoutView(model, view, font = INTER) {
                     return { x: r.x, y: r.y, ...(flowsRight ? { w: 18, h: w } : { w, h: 18 }) };
                 })()
                 : undefined;
-            ports.push({ edge: e.id, node: a.path, side: aSide, x: pts[0].x, y: pts[0].y }, { edge: e.id, node: b.path, side: bSide, x: pts[3].x, y: pts[3].y });
+            ports.push({ edge: e.id, node: ia.node, side: aSide, x: pts[0].x, y: pts[0].y }, { edge: e.id, node: ib.node, side: bSide, x: pts[3].x, y: pts[3].y });
             return { id: e.id, from: e.from, to: e.to, ...carry, points: pts, labelRect, coplanar: true };
         }
         // shelf: past the rank's far edge on the cross axis, measured over every

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squinch/core",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "The Squinch engine: parse, model, layout and deterministic SVG rendering for architecture diagrams as code.",
   "keywords": [
     "architecture",
@@ -33,11 +33,11 @@
     "@lezer/lr": "^1.4.10",
     "elkjs": "^0.12.0",
     "fast-xml-parser": "^5.10.1",
-    "@squinch/pack-aws": "0.1.1",
-    "@squinch/pack-logos": "0.1.1",
-    "@squinch/pack-sys": "0.1.1",
-    "@squinch/pack-k8s": "0.1.1",
-    "@squinch/pack-azure": "0.1.1"
+    "@squinch/pack-azure": "0.3.0",
+    "@squinch/pack-aws": "0.3.0",
+    "@squinch/pack-sys": "0.3.0",
+    "@squinch/pack-logos": "0.3.0",
+    "@squinch/pack-k8s": "0.3.0"
   },
   "devDependencies": {
     "@fontsource/ibm-plex-mono": "^5.3.0",