clearotron 0.3.2-beta.2 → 0.3.2-beta.4

package/portal-ui/dist/index.html

@@ -49,8 +49,8 @@
     -->
     <link rel="preconnect" href="https://api.fontshare.com" crossorigin />
     <link href="https://api.fontshare.com/v2/css?f[]=satoshi@400,500,700,900&display=swap" rel="stylesheet" />
-    <script type="module" crossorigin src="/portal/assets/index-BsbasHjM.js"></script>
-    <link rel="stylesheet" crossorigin href="/portal/assets/index-DNQpLYZF.css">
+    <script type="module" crossorigin src="/portal/assets/index-5UyqAyNM.js"></script>
+    <link rel="stylesheet" crossorigin href="/portal/assets/index-CVOIvdhc.css">
   </head>
   <body>
     <div id="root"></div>

package/portal-ui/package.json

@@ -2,7 +2,7 @@
   "name": "portal-ui",
   "private": true,
   "type": "module",
-  "version": "0.3.2-beta.2",
+  "version": "0.3.2-beta.4",
   "license": "AGPL-3.0-only",
   "description": "The unified trademark portal UI. One address, one login: who you are decides what you see. Built as a static bundle, served by driver/portal-service.mjs — the browser never reaches profile-service or recipe-service.",
   "engines": {

package/providers/_shared/script-form.mjs

@@ -106,8 +106,8 @@ export function romanizationRefusal(value) {
 }
 
 /** The two spellings a register may hold for one romanisation — syllable-separated as the record
- *  writes it, and run together as a searcher would type it. Probed: identical counts on CN/TW/GR/KR/TH,
- *  but EG differs (7 vs 10), so BOTH are emitted and OR-joined rather than picking one. */
+ *  writes it, and run together as a searcher would type it. On most scripts a register holds the two
+ *  spellings alike, but not on all of them — so BOTH are emitted and OR-joined rather than picking one. */
 export function romanizationSpellings(value) {
   const spaced = String(value ?? "").normalize("NFC").trim().replace(/\s+/g, " ");
   if (!spaced) return [];

package/providers/clarivate/src/core.js

@@ -220,8 +220,8 @@ export function assertSingleMarkShape(rawTerm) {
   }
   return tokens;
 }
-// Read as OPERATORS wherever they stand alone in a value string, case-insensitively ("monster adj
-// energy" = 67), with an optional proximity digit (ADJ2 = 72).
+// Read as OPERATORS wherever they stand alone in a value string, case-insensitively, with an
+// optional proximity digit.
 const RESERVED_TOKEN_RE = /^(?:AND|OR|NOT|ADJ|NEAR)\d*$/i;
 const PUNCT_ONLY_RE = /^[^\p{L}\p{N}]+$/u;
 
@@ -229,22 +229,18 @@ const PUNCT_ONLY_RE = /^[^\p{L}\p{N}]+$/u;
  * An operator word inside a phrase is DROPPED, and the gap it leaves is spanned by widening that one
  * adjacency to `ADJ<n+1>`.
  *
- * The obvious move — make the word lexically stop being an operator with an interior `?` — is WRONG,
- * and measurably so. Registers write these marks with an ampersand, not the word:
- *
- *   *BLACK ADJ A?D ADJ DECKER*   0      ← what the `?` escape asks for, and nothing is named that
- *   *BLACK ADJ DECKER*          55      ← BLACK & DECKER
- *   *BLACK ADJ2 DECKER*         55      ← identical: the connector is not indexed, so spanning costs nothing
- *   *BEN ADJ A?D ADJ JERRYS*     0   vs  *BEN ADJ JERRYS*  25
+ * The obvious move — make the word lexically stop being an operator with an interior `?` — is WRONG.
+ * Registers write these marks with an ampersand and not the word, so the escaped form names NOTHING,
+ * while the plain adjacency finds the mark and the widened adjacency finds exactly the same set.
  *
  * A zero over a mark that exists is the failure this whole contract is built to prevent, so the escape
  * is gone. Dropping + `ADJ2` is right whether or not the index holds the word: if it is a stopword the
- * neighbours are already adjacent (55 == 55 above), and if some register does index it the widened
- * adjacency still reaches across. It is a superset of the literal phrase — safe in the direction a
- * clearance sweep needs, which fails by MISSING a mark and never by surfacing an extra one.
+ * neighbours are already adjacent — plain and widened return the same set — and if some register does
+ * index it the widened adjacency still reaches across. It is a superset of the literal phrase — safe in
+ * the direction a clearance sweep needs, which fails by MISSING a mark and never by surfacing an extra one.
  *
- * `ADJ<n>` is real and probed: MONSTER ADJ ENERGY = 67, MONSTER ADJ2 ENERGY = 72, SALT ADJ PEPPER = 27
- * vs SALT ADJ2 PEPPER = 52 — so the widening is genuinely a widening, not a no-op we cannot see.
+ * `ADJ<n>` is real: the widened form returns strictly more than the tighter one, so the widening is
+ * genuinely a widening and not a no-op we cannot see.
  */
 export function isReservedToken(tok) {
   return RESERVED_TOKEN_RE.test(tok);
@@ -286,21 +282,16 @@ export function compilePhraseValue(term, { pre = "", post = "", dropReserved = f
 
   // A LEADING `*` on a ONE-CHARACTER first token is a sub-query over most of the register, and inside an
   // ADJ chain the provider gives up on it: HTTP 500 "Near/Adj queries with sub queries that can return a
-  // huge amount…". Probed — one character breaks, two do not:
-  //   *I ADJ CANT ADJ BELIEVE*  500      *IT ADJ STARTS ADJ WITH*  103
-  //   *A ADJ BAR*               500      *AN ADJ APPLE*             55
-  // So the leading wrap is dropped for that one case, and ONLY that case. It costs a little recall at
-  // the leading token boundary (AN ADJ APPLE* = 31 vs *AN ADJ APPLE* = 55), which is why it is not done
-  // generally — but the alternative here is not a narrower search, it is no search at all.
+  // huge amount…". The refusal is specific to a first token of ONE character; two characters are answered.
+  // So the leading wrap is dropped for that one case, and ONLY that case. It costs a little recall at the
+  // leading token boundary, which is why it is not done generally — but the alternative here is not a
+  // narrower search, it is no search at all.
   const leadWrap = (kept.length > 1 && kept[0].length === 1) ? "" : pre;
   // AND THE SAME AT THE OTHER END, which was never added and cost a family search on a live matter. A
   // root whose LAST word is one character — a sequel number, an article, an initial — compiled to
   // `*PLAN ADJ B*`, and the trailing `B*` is the same sub-query over most of the register that the
-  // leading rule above exists for. Probed on the test install, count calls only:
-  //   *PLAN ADJ B*   500      *PLAN ADJ B    200, 36 records
-  //   *LEVEL ADJ 2*  500      *LEVEL ADJ 2   200, 14 records
-  //   *ROB ADJ A*    500      *ROB ADJ A     200,  3 records
-  // A delivered run planned a family search on such a root, every attempt was refused, the refusal was
+  // leading rule above exists for: the provider refuses that shape and answers the same query with the
+  // trailing star removed. A delivered run planned a family search on such a root, every attempt was refused, the refusal was
   // retried as if transient and the slice was filed as a provider gap — so a family of pending filings
   // for a third-party title went unseen and the matter was rated on what was left.
   const last = kept.length - 1;
@@ -517,8 +508,8 @@ export function hasAnyElement(p) {
 
 /**
  * Join terms into ONE value string with the EXPLICIT " OR " operator (a bare space is an implicit AND,
- * not an OR). ADJ binds tighter than OR, so phrase operands need no parentheses — probed:
- * `*MOUNTAIN ADJ DEW* OR *MONSTER ADJ ENERGY*` = 157 = 90 + 67, identical with parens.
+ * not an OR). ADJ binds tighter than OR, so phrase operands need no parentheses: an OR of two phrases
+ * returns the union of the two, and parentheses around them change nothing.
  * The width bound is the parser's document-nesting cap; the enumerate
  * kernel chunks wide `names` stacks at capabilities.kernel.namesChunkDefault (= maxOrWidth) before they
  * ever reach here, so hitting this throw means a caller bypassed the kernel.

package/providers/oauth-mcp-bridge/CHANGELOG.md

@@ -1,5 +1,13 @@
 # trademark-oauth-mcp-bridge
 
+## 0.3.2-beta.4
+
+No changes in this release.
+
+## 0.3.2-beta.3
+
+No changes in this release.
+
 ## 0.3.2-beta.2
 
 No changes in this release.

package/providers/oauth-mcp-bridge/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trademark-oauth-mcp-bridge",
-  "version": "0.3.2-beta.2",
+  "version": "0.3.2-beta.4",
   "license": "AGPL-3.0-only",
   "private": true,
   "description": "OAuth 2.1 MCP stdio bridge used by the engine's case-law gather stage (courtlistener / legaldatahunter).",

package/providers/signa/src/core.js

@@ -793,9 +793,9 @@ export async function doCountHits(apiKey, base, params, tctx, { mock = false } =
   const parsed = JSON.parse(r.text);
   // ── this is a COUNT now, and it was a presence probe ──────────────────────────────────
   // `include_total` returns the corpus total on the same call, so the smallest request the API will
-  // take — limit 1 — carries the whole answer: probed, `limit:1` returned total 685, identical to the
-  // paged query's. Stage 0.5 (driver/register-count.mjs) refused to run on this provider at all; it
-  // now gets the number it exists to ask for.
+  // take — limit 1 — carries the whole answer: the total it reports is the one the paged query reports.
+  // Stage 0.5 (driver/register-count.mjs) refused to run on this provider at all; it now gets the
+  // number it exists to ask for.
   //
   // THE ZERO RULE IS UNCHANGED AND IS THE REASON THIS IS SAFE. `total_hits` is null unless the vendor
   // counted exactly — an approximation and a non-answer both report unknown. So the only 0 this can