@konneal/engine 0.2.43 → 0.2.44

package/dist/{ask-72UZSXFM.js → ask-JOX2D7KH.js}

@@ -1,6 +1,6 @@
 import {
   handleAsk
-} from "./chunk-IEM2XBLP.js";
+} from "./chunk-HDUSO5S5.js";
 import "./chunk-N2UOENDY.js";
 import "./chunk-R2V3X6SQ.js";
 import "./chunk-A3QHHUN5.js";

package/dist/certificates.d.ts

@@ -16,6 +16,18 @@ export declare function isRegisterShaped(query: string): boolean;
  *  numbers ("190", "HM14H1"). Upper-cased tokens match case-insensitively
  *  in SQL LIKE. */
 export declare function registerTokens(query: string): string[];
+/** The register query for a token set. Numeric tokens (a model number
+ *  like "190") must match as a STANDALONE value — `LIKE '%190%'` also
+ *  catches "XK3190", which the live Utilcell probe demonstrated — so a
+ *  number matches the exact model, or as a delimiter-separated word
+ *  (hyphens and punctuation normalize to spaces). Word tokens keep the
+ *  substring LIKE (names and model words do not overmatch the way
+ *  numbers do). Each token takes its own numbered placeholder,
+ *  referenced three times (holder, model, number). */
+export declare function buildRegisterQuery(tokens: string[]): {
+    sql: string;
+    params: string[];
+};
 export declare function searchRegister(db: any, query: string): Promise<{
     rows: RegisterRow[];
     tokens: string[];

package/dist/{chunk-IEM2XBLP.js → chunk-HDUSO5S5.js}

@@ -1810,17 +1810,32 @@ function registerTokens(query) {
   }
   return tokens2.slice(0, 6);
 }
+function buildRegisterQuery(tokens2) {
+  const params = [];
+  const clauses = tokens2.map((t) => {
+    if (/^\d+$/.test(t)) {
+      const padded = `% ${t.toLowerCase()} %`;
+      params.push(t, t, padded);
+      const n1 = params.length - 2;
+      const n2 = params.length;
+      return `(model = ?${n1} OR num = ?${n1} OR (' ' || REPLACE(REPLACE(REPLACE(LOWER(model), '-', ' '), ',', ' '), '.', ' ') || ' ') LIKE ?${n2})`;
+    }
+    params.push(`%${t}%`);
+    const n = params.length;
+    return `(holder LIKE ?${n} OR model LIKE ?${n} OR num LIKE ?${n})`;
+  });
+  return {
+    sql: `SELECT num, family, holder, model, year, status FROM certificates WHERE ${clauses.join(" OR ")} LIMIT 6`,
+    params
+  };
+}
 async function searchRegister(db, query) {
   if (!isRegisterShaped(query)) return null;
   const tokens2 = registerTokens(query);
   if (!tokens2.length) return null;
-  const clauses = tokens2.map((_, i) => {
-    const n = i + 1;
-    return `(holder LIKE ?${n} OR model LIKE ?${n} OR num LIKE ?${n})`;
-  }).join(" OR ");
-  const params = tokens2.map((t) => `%${t}%`);
+  const { sql, params } = buildRegisterQuery(tokens2);
   try {
-    const res = await db.prepare(`SELECT num, family, holder, model, year, status FROM certificates WHERE ${clauses} LIMIT 6`).bind(...params).all();
+    const res = await db.prepare(sql).bind(...params).all();
     return { rows: res.results ?? [], tokens: tokens2 };
   } catch {
     return { rows: [], tokens: tokens2 };

package/dist/worker_public/src/index.js

@@ -9,7 +9,7 @@ import {
   modelGroundingBlock,
   scoreJudge,
   standardForDocNumber
-} from "../../chunk-IEM2XBLP.js";
+} from "../../chunk-HDUSO5S5.js";
 import {
   buildMessages,
   citations,
@@ -999,7 +999,7 @@ async function handleMcp(env, ctx, req, tier, key) {
       // stream:false forces the JSON lane (anon defaults to SSE)
       body: JSON.stringify({ ...args, stream: false })
     });
-    const res = name === "ask" ? await (await import("../../ask-72UZSXFM.js")).handleAsk(env, ctx, inner, tier, key) : await (await import("../../search-QZDQVB57.js")).handleSearch(env, ctx, inner, tier, key);
+    const res = name === "ask" ? await (await import("../../ask-JOX2D7KH.js")).handleAsk(env, ctx, inner, tier, key) : await (await import("../../search-QZDQVB57.js")).handleSearch(env, ctx, inner, tier, key);
     return res.json().catch(() => ({ error: { message: "tool transport failed", status: res.status } }));
   });
   if (out.ok && "accepted" in out) return new Response(null, { status: 202 });

package/package.json

@@ -27,7 +27,7 @@
     "playwright": "^1.62.1",
     "yaml": "^2.9.1"
   },
-  "version": "0.2.43",
+  "version": "0.2.44",
   "description": "The Konneal engine: the publisher-agnostic build pipeline and API plane for standards intelligence (retrieval, answer contract, verdicts, evaluation).",
   "license": "BSD-3-Clause",
   "type": "module",

package/workers/worker_public/src/certificates.ts

@@ -48,23 +48,45 @@ export function registerTokens(query: string): string[] {
   return tokens.slice(0, 6);
 }
 
+/** The register query for a token set. Numeric tokens (a model number
+ *  like "190") must match as a STANDALONE value — `LIKE '%190%'` also
+ *  catches "XK3190", which the live Utilcell probe demonstrated — so a
+ *  number matches the exact model, or as a delimiter-separated word
+ *  (hyphens and punctuation normalize to spaces). Word tokens keep the
+ *  substring LIKE (names and model words do not overmatch the way
+ *  numbers do). Each token takes its own numbered placeholder,
+ *  referenced three times (holder, model, number). */
+export function buildRegisterQuery(tokens: string[]): { sql: string; params: string[] } {
+  const params: string[] = [];
+  const clauses = tokens.map((t) => {
+    if (/^\d+$/.test(t)) {
+      // a number matches as a STANDALONE value: the exact model or
+      // certificate number, or a delimiter-separated word (hyphens and
+      // punctuation normalize to spaces) — never a substring ("190"
+      // must not catch "XK3190")
+      const padded = `% ${t.toLowerCase()} %`;
+      params.push(t, t, padded);
+      const n1 = params.length - 2;
+      const n2 = params.length;
+      return `(model = ?${n1} OR num = ?${n1} OR (' ' || REPLACE(REPLACE(REPLACE(LOWER(model), '-', ' '), ',', ' '), '.', ' ') || ' ') LIKE ?${n2})`;
+    }
+    params.push(`%${t}%`);
+    const n = params.length;
+    return `(holder LIKE ?${n} OR model LIKE ?${n} OR num LIKE ?${n})`;
+  });
+  return {
+    sql: `SELECT num, family, holder, model, year, status FROM certificates WHERE ${clauses.join(" OR ")} LIMIT 6`,
+    params,
+  };
+}
+
 export async function searchRegister(db: any, query: string): Promise<{ rows: RegisterRow[]; tokens: string[] } | null> {
   if (!isRegisterShaped(query)) return null;
   const tokens = registerTokens(query);
   if (!tokens.length) return null;
-  // each token takes its own numbered placeholder, referenced three
-  // times (holder, model, number) — a shared ?1 would silently search
-  // the first token only
-  const clauses = tokens.map((_, i) => {
-    const n = i + 1;
-    return `(holder LIKE ?${n} OR model LIKE ?${n} OR num LIKE ?${n})`;
-  }).join(" OR ");
-  const params = tokens.map((t) => `%${t}%`);
+  const { sql, params } = buildRegisterQuery(tokens);
   try {
-    const res = await db
-      .prepare(`SELECT num, family, holder, model, year, status FROM certificates WHERE ${clauses} LIMIT 6`)
-      .bind(...params)
-      .all();
+    const res = await db.prepare(sql).bind(...params).all();
     return { rows: (res.results ?? []) as RegisterRow[], tokens };
   } catch {
     // a missing table or a D1 hiccup degrades to no-note honestly