@pixerate/editor 0.227.1 → 0.228.1

package/dist/{chunk-OJTZKDLJ.cjs → chunk-KBNCEZZB.cjs}

@@ -3,7 +3,7 @@
 
 
 
-var _chunkZ7BVK32Ccjs = require('./chunk-Z7BVK32C.cjs');
+var _chunkRTPBM46Fcjs = require('./chunk-RTPBM46F.cjs');
 
 // src/bridge/index.ts
 var _http = require('http');
@@ -197,7 +197,7 @@ var SKILL_INSTRUCTIONS = "Each editor's tools are documented by an agent skill (
 async function createToolBridge(options) {
   const log = _nullishCoalesce(options.log, () => ( ((message) => process.stderr.write(`[${options.name}] ${message}
 `))));
-  const port = _nullishCoalesce(options.port, () => ( _chunkZ7BVK32Ccjs.TOOL_BRIDGE_DEFAULT_PORT));
+  const port = _nullishCoalesce(options.port, () => ( _chunkRTPBM46Fcjs.TOOL_BRIDGE_DEFAULT_PORT));
   const retryMs = _nullishCoalesce(options.retryMs, () => ( 2e3));
   const timeoutMs = _nullishCoalesce(options.timeoutMs, () => ( 6e4));
   const extraOrigins = new Set(_nullishCoalesce(options.origins, () => ( [])));
@@ -211,7 +211,7 @@ async function createToolBridge(options) {
   let closed = false;
   let retry;
   const send = (editor, message) => editor.socket.send(JSON.stringify(message));
-  const registry = new (0, _chunkZ7BVK32Ccjs.ToolRegistry)();
+  const registry = new (0, _chunkRTPBM46Fcjs.ToolRegistry)();
   const listeners = /* @__PURE__ */ new Set();
   const toolsChanged = () => listeners.forEach((l) => l());
   const describeEditors = () => [...editors.values()].map((e) => `${e.id} (${e.name})`).join(", ");
@@ -319,13 +319,13 @@ async function createToolBridge(options) {
         return;
       }
       if (message.t === "hello") {
-        if (message.v !== _chunkZ7BVK32Ccjs.TOOL_BRIDGE_PROTOCOL) {
+        if (message.v !== _chunkRTPBM46Fcjs.TOOL_BRIDGE_PROTOCOL) {
           log(`refused an editor speaking protocol v${String(message.v)}`);
-          return ws.close(1008, `This bridge speaks protocol v${_chunkZ7BVK32Ccjs.TOOL_BRIDGE_PROTOCOL}; update @pixerate/editor.`);
+          return ws.close(1008, `This bridge speaks protocol v${_chunkRTPBM46Fcjs.TOOL_BRIDGE_PROTOCOL}; update @pixerate/editor.`);
         }
         editor = { id: `e${++editorCounter}`, name: String(message.name || "Editor"), ...message.kind ? { kind: message.kind } : {}, socket: ws, tools: Array.isArray(message.tools) ? message.tools : [], activeAt: Date.now(), activeSeq: ++activity };
         editors.set(editor.id, editor);
-        ws.send(JSON.stringify({ t: "welcome", v: _chunkZ7BVK32Ccjs.TOOL_BRIDGE_PROTOCOL, id: editor.id }));
+        ws.send(JSON.stringify({ t: "welcome", v: _chunkRTPBM46Fcjs.TOOL_BRIDGE_PROTOCOL, id: editor.id }));
         log(`editor ${editor.id} connected: ${editor.name} (${editor.tools.length} tools)`);
         toolsChanged();
       } else if (message.t === "tools" && editor) {
@@ -381,7 +381,7 @@ async function createToolBridge(options) {
 `)]);
   const skills = options.skills === false ? {} : _nullishCoalesce(options.skills, () => ( loadSkillFiles()));
   const hasSkills = Object.keys(skills).length > 0;
-  const mcp = _chunkZ7BVK32Ccjs.createMcpServer.call(void 0, registry, {
+  const mcp = _chunkRTPBM46Fcjs.createMcpServer.call(void 0, registry, {
     name: options.name,
     version: _nullishCoalesce(options.version, () => ( "0.1.0")),
     instructions: [options.instructions, BRIDGE_INSTRUCTIONS, hasSkills ? SKILL_INSTRUCTIONS : ""].filter(Boolean).join("\n\n"),

package/dist/{chunk-7KZ2HKKC.js → chunk-LPFQHVCO.js}

@@ -430,6 +430,238 @@ function matchArrangeShortcut(event, bindings = DEFAULT_ARRANGE_SHORTCUTS) {
   return arrangeShortcutMap(bindings).resolve(event)?.command ?? null;
 }
 
+// src/canvas/gestures.ts
+function gestureRandom(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 >>> 0;
+    let t = a;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function gestureSeed(value) {
+  const text = JSON.stringify(value) ?? "";
+  let h = 2166136261;
+  for (let i = 0; i < text.length; i++) {
+    h ^= text.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+function gestureUnion(rects) {
+  if (!rects.length) throw new Error("Pass at least one rect.");
+  const x = Math.min(...rects.map((r) => r.x));
+  const y = Math.min(...rects.map((r) => r.y));
+  const right = Math.max(...rects.map((r) => r.x + r.width));
+  const bottom = Math.max(...rects.map((r) => r.y + r.height));
+  return { x, y, width: right - x, height: bottom - y };
+}
+var clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+var centre = (r) => [r.x + r.width / 2, r.y + r.height / 2];
+function smoothNoise(rand, octaves = 3) {
+  const waves = Array.from({ length: octaves }, (_, i) => ({ f: (i + 1) * (0.6 + rand() * 0.8), phase: rand() * Math.PI * 2, amp: 1 / (i + 1) }));
+  const total = waves.reduce((sum, w) => sum + w.amp, 0);
+  return (t) => waves.reduce((sum, w) => sum + w.amp * Math.sin(2 * Math.PI * w.f * t + w.phase), 0) / total;
+}
+function handPressure(rand) {
+  const r = (lo, hi) => Math.round((lo + rand() * (hi - lo)) * 100) / 100;
+  return [r(0.35, 0.55), r(0.8, 0.95), r(0.9, 1), r(0.75, 0.95), r(0.4, 0.65)];
+}
+var round = (p) => [Math.round(p[0] * 100) / 100, Math.round(p[1] * 100) / 100];
+function wobblyLine(a, b, rand, amp, bow = 0) {
+  const dx = b[0] - a[0];
+  const dy = b[1] - a[1];
+  const len = Math.hypot(dx, dy);
+  if (len === 0) return [a];
+  const nx = -dy / len;
+  const ny = dx / len;
+  const noise = smoothNoise(rand);
+  const n = clamp(Math.ceil(len / 4), 8, 200);
+  return Array.from({ length: n + 1 }, (_, i) => {
+    const t = i / n;
+    const off = bow * 4 * t * (1 - t) + amp * noise(t) * Math.sqrt(Math.sin(Math.PI * t));
+    return [a[0] + dx * t + nx * off, a[1] + dy * t + ny * off];
+  });
+}
+function circleGesture(rect, seed, options = {}) {
+  const rand = gestureRandom(seed);
+  const pad = Math.max(0, options.padding ?? 8);
+  const [cx, cy] = centre(rect);
+  const tilt = (rand() - 0.5) * 0.08;
+  const c = Math.abs(Math.cos(tilt));
+  const s = Math.abs(Math.sin(tilt));
+  const a = (rect.width / 2 * c + rect.height / 2 * s) * Math.SQRT2 + pad;
+  const b = (rect.width / 2 * s + rect.height / 2 * c) * Math.SQRT2 + pad;
+  const dir = rand() < 0.7 ? -1 : 1;
+  const start = -Math.PI * 0.75 + (rand() - 0.5) * 0.6;
+  const sweep = Math.PI * 2 + Math.PI * (0.1 + rand() * 0.12);
+  const jitter = 0.03 + rand() * 0.03;
+  const drift = 0.04 + rand() * 0.05;
+  const noise = smoothNoise(rand, 4);
+  const perimeter = Math.PI * (3 * (a + b) - Math.sqrt((3 * a + b) * (a + 3 * b)));
+  const n = clamp(Math.ceil(perimeter * (sweep / (Math.PI * 2)) / 5), 48, 360);
+  const points = Array.from({ length: n + 1 }, (_, i) => {
+    const t = i / n;
+    const angle = start + dir * sweep * t;
+    const grow = 1 + jitter * (0.5 + 0.5 * noise(t)) + drift * t * t;
+    const ex = a * grow * Math.cos(angle);
+    const ey = b * grow * Math.sin(angle);
+    return round([cx + ex * Math.cos(tilt) - ey * Math.sin(tilt), cy + ex * Math.sin(tilt) + ey * Math.cos(tilt)]);
+  });
+  return { points, pressure: handPressure(rand) };
+}
+function underlineGesture(rect, seed, options = {}) {
+  const rand = gestureRandom(seed);
+  const offset = Math.max(0, options.offset ?? 4);
+  const amp = options.wave ? clamp(rect.width * 0.02, 2, 4) : 0;
+  const shake = Math.min(1.5, offset * 0.4);
+  const base = rect.y + rect.height + offset + amp + shake;
+  const slope = Math.min(6, rect.width * 0.03);
+  const x0 = rect.x - rect.width * (0.01 + rand() * 0.04);
+  const x1 = rect.x + rect.width * (0.96 + rand() * 0.08);
+  const line = wobblyLine([x0, base + rand() * slope], [x1, base + rand() * slope], rand, shake, (rand() - 0.5) * 2 * shake);
+  const wavelength = clamp(rect.width / 8, 12, 28);
+  const phase = rand() * Math.PI * 2;
+  const points = amp ? line.map(([x, y]) => [x, y + amp * Math.sin(2 * Math.PI * (x - x0) / wavelength + phase)]) : line;
+  return { points: points.map(round), pressure: handPressure(rand) };
+}
+function gestureEdgePoint(rect, toward, gap = 0) {
+  const [cx, cy] = centre(rect);
+  const dx = toward[0] - cx;
+  const dy = toward[1] - cy;
+  const len = Math.hypot(dx, dy);
+  if (len === 0) return [cx, cy];
+  const t = Math.min(dx ? rect.width / 2 / Math.abs(dx) : Infinity, dy ? rect.height / 2 / Math.abs(dy) : Infinity);
+  return [cx + dx * t + dx / len * gap, cy + dy * t + dy / len * gap];
+}
+var isRect = (end) => !Array.isArray(end);
+function arrowGesture(from, to, seed, options = {}) {
+  const rand = gestureRandom(seed);
+  const gap = Math.max(0, options.gap ?? 6);
+  const fromCentre = isRect(from) ? centre(from) : from;
+  const toCentre = isRect(to) ? centre(to) : to;
+  const start = isRect(from) ? gestureEdgePoint(from, toCentre, gap) : from;
+  const tip = isRect(to) ? gestureEdgePoint(to, fromCentre, gap) : to;
+  const dx = tip[0] - start[0];
+  const dy = tip[1] - start[1];
+  const len = Math.hypot(dx, dy);
+  if (len < 4) throw new Error("The arrow's ends are too close together (or overlap): pass ends at least a few canvas units apart.");
+  const curve = clamp(options.curve ?? (0.08 + rand() * 0.08) * (rand() < 0.5 ? -1 : 1), -1, 1);
+  const nx = -dy / len;
+  const ny = dx / len;
+  const control = [(start[0] + tip[0]) / 2 + nx * curve * len, (start[1] + tip[1]) / 2 + ny * curve * len];
+  const noise = smoothNoise(rand);
+  const amp = Math.min(2, len * 0.01);
+  const n = clamp(Math.ceil(len / 4), 12, 200);
+  const shaft = Array.from({ length: n + 1 }, (_, i) => {
+    const t = i / n;
+    const u = 1 - t;
+    const x = u * u * start[0] + 2 * u * t * control[0] + t * t * tip[0];
+    const y = u * u * start[1] + 2 * u * t * control[1] + t * t * tip[1];
+    const off = amp * noise(t) * Math.sqrt(Math.sin(Math.PI * t));
+    return [x + nx * off, y + ny * off];
+  });
+  const tx = tip[0] - control[0];
+  const ty = tip[1] - control[1];
+  const tl = Math.hypot(tx, ty) || 1;
+  const head = clamp(len * 0.15, 8, 22);
+  const barb = (angle2, length) => {
+    const c = Math.cos(angle2);
+    const s = Math.sin(angle2);
+    const bx = -(tx / tl) * c + ty / tl * s;
+    const by = -(ty / tl) * c - tx / tl * s;
+    return [1 / 3, 2 / 3, 1].map((f) => [tip[0] + bx * length * f, tip[1] + by * length * f]);
+  };
+  const clear = (pts) => !isRect(to) || pts.every(([x, y]) => x <= to.x || x >= to.x + to.width || y <= to.y || y >= to.y + to.height);
+  const fit = (angle2) => {
+    const length = head * (0.85 + rand() * 0.3);
+    for (let k = 1; k > 0.05; k -= 0.15) {
+      const pts = barb(angle2 * k, length);
+      if (clear(pts)) return pts;
+    }
+    return barb(0, length);
+  };
+  const angle = () => (25 + rand() * 8) * Math.PI / 180;
+  const first = fit(angle());
+  const second = fit(-angle());
+  const points = [...shaft, ...first, ...first.slice(0, -1).reverse(), tip, ...second];
+  return { points: points.map(round), pressure: handPressure(rand) };
+}
+function bracketGesture(rect, side, seed, options = {}) {
+  const rand = gestureRandom(seed);
+  const pad = Math.max(0, options.padding ?? 8);
+  const vertical = side === "left" || side === "right";
+  const span = vertical ? rect.height : rect.width;
+  const depth = Math.max(1, options.depth ?? clamp(span * 0.08, 6, 20));
+  const from = vertical ? rect.y : rect.x;
+  const edge = side === "left" ? rect.x - pad : side === "right" ? rect.x + rect.width + pad : side === "top" ? rect.y - pad : rect.y + rect.height + pad;
+  const out = side === "left" || side === "top" ? -1 : 1;
+  const at = (s, d) => vertical ? [edge + out * d, from + s * span] : [from + s * span, edge + out * d];
+  const noise = smoothNoise(rand);
+  const shake = Math.min(1, depth * 0.06);
+  const n = clamp(Math.ceil(span / 4), 24, 240);
+  let points;
+  if (options.shape === "square") {
+    const arm = depth * (0.8 + rand() * 0.2);
+    const spine = Array.from({ length: n + 1 }, (_, i) => at(i / n, depth + shake * (1 + noise(i / n))));
+    points = [at(0, depth - arm), at(0, depth * 0.5), ...spine, at(1, depth * 0.5), at(1, depth - arm * (0.85 + rand() * 0.15))];
+  } else {
+    const e = clamp(depth / Math.max(span, 1), 0.04, 0.2);
+    const brace = (s) => {
+      const u = s <= 0.5 ? s : 1 - s;
+      if (u < e) return depth / 2 * Math.sin(Math.PI / 2 * u / e);
+      if (u < 0.5 - e) return depth / 2;
+      return depth / 2 + depth / 2 * (1 - Math.cos(Math.PI / 2 * (u - (0.5 - e)) / e));
+    };
+    points = Array.from({ length: n + 1 }, (_, i) => {
+      const s = i / n;
+      return at(s, brace(s) + shake * (1 + noise(s)) * Math.sin(Math.PI * s));
+    });
+  }
+  return { points: points.map(round), pressure: handPressure(rand) };
+}
+function strikeGesture(rect, seed) {
+  const rand = gestureRandom(seed);
+  const [, cy] = centre(rect);
+  const slope = rect.height * 0.08;
+  const x0 = rect.x - rect.width * (0.01 + rand() * 0.03);
+  const x1 = rect.x + rect.width * (1.01 + rand() * 0.03);
+  const y0 = cy + (rand() - 0.5) * rect.height * 0.1 + slope * (rand() - 0.5);
+  const y1 = cy + (rand() - 0.5) * rect.height * 0.1 + slope * (rand() - 0.5);
+  const points = wobblyLine([x0, y0], [x1, y1], rand, Math.min(1.5, rect.height * 0.05));
+  return { points: points.map(round), pressure: handPressure(rand) };
+}
+function crossGesture(rect, seed) {
+  const rand = gestureRandom(seed);
+  const over = () => 0.02 + rand() * 0.04;
+  const left = () => rect.x - rect.width * over();
+  const right = () => rect.x + rect.width * (1 + over());
+  const top = () => rect.y - rect.height * over();
+  const bottom = () => rect.y + rect.height * (1 + over());
+  const amp = Math.min(1.5, Math.min(rect.width, rect.height) * 0.03);
+  const first = wobblyLine([left(), top()], [right(), bottom()], rand, amp);
+  const second = wobblyLine([right(), top()], [left(), bottom()], rand, amp);
+  const mid1 = Math.floor(first.length / 2);
+  const mid2 = Math.floor(second.length / 2);
+  const points = [...first, ...first.slice(mid1, -1).reverse(), ...second.slice(1, mid2 + 1).reverse(), ...second];
+  return { points: points.map(round), pressure: handPressure(rand) };
+}
+function checkGesture(at, seed, options = {}) {
+  const rand = gestureRandom(seed);
+  const [cx, cy] = isRect(at) ? centre(at) : at;
+  const s = Math.max(4, options.size ?? (isRect(at) ? clamp(Math.min(at.width, at.height) * 0.6, 12, 48) : 20));
+  const turn = (rand() - 0.5) * 12 * Math.PI / 180;
+  const place = ([x, y]) => [cx + s * (x * Math.cos(turn) - y * Math.sin(turn)), cy + s * (x * Math.sin(turn) + y * Math.cos(turn))];
+  const p0 = [-0.42 + rand() * 0.08, -0.05 + rand() * 0.08];
+  const p1 = [-0.12 + rand() * 0.06, 0.38 + rand() * 0.06];
+  const p2 = [0.48 + rand() * 0.06, -0.5 + rand() * 0.06];
+  const short = wobblyLine(place(p0), place(p1), rand, 0, -s * 0.03);
+  const long = wobblyLine(place(p1), place(p2), rand, Math.min(1, s * 0.02), s * 0.06);
+  return { points: [...short, ...long.slice(1)].map(round), pressure: [0.5, 0.95, 0.9, 0.7, 0.35] };
+}
+
 export {
   PLATFORMS,
   detectPlatform,
@@ -448,5 +680,16 @@ export {
   toShortcutBindings,
   ShortcutMap,
   DEFAULT_ARRANGE_SHORTCUTS,
-  matchArrangeShortcut
+  matchArrangeShortcut,
+  gestureRandom,
+  gestureSeed,
+  gestureUnion,
+  circleGesture,
+  underlineGesture,
+  gestureEdgePoint,
+  arrowGesture,
+  bracketGesture,
+  strikeGesture,
+  crossGesture,
+  checkGesture
 };

package/dist/{chunk-H73MSHYZ.js → chunk-QTMQ5TGA.js}

@@ -1,6 +1,6 @@
 import {
   parseSkillFrontmatter
-} from "./chunk-SAN4SBBS.js";
+} from "./chunk-ABHOYBZD.js";
 import {
   readingTime
 } from "./chunk-EHTX34RE.js";

package/dist/{chunk-Z7BVK32C.cjs → chunk-RTPBM46F.cjs}

@@ -806,6 +806,17 @@ function summarize(description, max = 200) {
 }
 var COMMON_VERBS = /* @__PURE__ */ new Set(["add", "set", "get", "remove", "list", "update", "change", "make", "create", "delete", "read", "show", "put", "use", "edit"]);
 var WEIGHTS = { name: 4, title: 2.5, toolset: 1.5, description: 1, params: 0.5 };
+var tokenCache = /* @__PURE__ */ new Map();
+var TOKEN_CACHE_LIMIT = 2e4;
+function tokenSet(text) {
+  let tokens = tokenCache.get(text);
+  if (!tokens) {
+    if (tokenCache.size >= TOKEN_CACHE_LIMIT) tokenCache.clear();
+    tokens = new Set(searchTokens(text));
+    tokenCache.set(text, tokens);
+  }
+  return tokens;
+}
 function paramText(schema, depth = 0) {
   if (!schema || typeof schema !== "object" || depth > 2) return "";
   const s = schema;
@@ -817,17 +828,24 @@ function paramText(schema, depth = 0) {
   if (Array.isArray(s.anyOf)) for (const branch of s.anyOf) parts.push(paramText(branch, depth + 1));
   return parts.join(" ");
 }
-function document(tool, toolset) {
+var schemaTextCache = /* @__PURE__ */ new WeakMap();
+function schemaText(schema) {
+  let text = schemaTextCache.get(schema);
+  if (text === void 0) {
+    text = paramText(schema);
+    schemaTextCache.set(schema, text);
+  }
+  return text;
+}
+function document(tool, toolset, toolsetTokens) {
   const fields = {
-    name: new Set(searchTokens(baseToolName(tool.name))),
-    title: new Set(searchTokens(_nullishCoalesce(_nullishCoalesce(tool.title, () => ( _optionalChain([tool, 'access', _22 => _22.annotations, 'optionalAccess', _23 => _23.title]))), () => ( "")))),
-    toolset: new Set(searchTokens(`${toolset.name} ${_nullishCoalesce(toolset.title, () => ( ""))} ${_nullishCoalesce(toolset.description, () => ( ""))}`)),
-    description: new Set(searchTokens(_nullishCoalesce(tool.description, () => ( "")))),
-    params: new Set(searchTokens(paramText(tool.inputSchema)))
+    name: tokenSet(baseToolName(tool.name)),
+    title: tokenSet(_nullishCoalesce(_nullishCoalesce(tool.title, () => ( _optionalChain([tool, 'access', _22 => _22.annotations, 'optionalAccess', _23 => _23.title]))), () => ( ""))),
+    toolset: toolsetTokens,
+    description: tokenSet(_nullishCoalesce(tool.description, () => ( ""))),
+    params: tokenSet(schemaText(tool.inputSchema))
   };
-  const all = /* @__PURE__ */ new Set();
-  for (const set of Object.values(fields)) for (const t of set) all.add(t);
-  return { tool, toolset, fields, all };
+  return { tool, toolset, fields };
 }
 function matchValue(tokens, word, alternatives, idf) {
   const rarity = _nullishCoalesce(idf.get(word), () => ( 1));
@@ -849,18 +867,25 @@ function matchValue(tokens, word, alternatives, idf) {
 function searchTools(tools, toolsets, query, options = {}) {
   const setOf = /* @__PURE__ */ new Map();
   for (const set of toolsets) for (const name of set.tools) setOf.set(name, set);
-  const docs = tools.flatMap((tool) => {
+  const setTokens = /* @__PURE__ */ new Map();
+  const all = tools.map((tool) => {
     const set = _nullishCoalesce(setOf.get(tool.name), () => ( { name: "", providers: [], tools: [tool.name] }));
-    return !options.toolset || set.name === options.toolset ? [document(tool, set)] : [];
+    let tokens = setTokens.get(set);
+    if (!tokens) {
+      tokens = tokenSet(`${set.name} ${_nullishCoalesce(set.title, () => ( ""))} ${_nullishCoalesce(set.description, () => ( ""))}`);
+      setTokens.set(set, tokens);
+    }
+    return document(tool, set, tokens);
   });
+  const docs = options.toolset ? all.filter((d) => d.toolset.name === options.toolset) : all;
   const words = Array.from(new Set(searchTokens(query)));
   if (words.length === 0 || docs.length === 0) return [];
   const alternatives = new Map(words.map((w) => [w, (_nullishCoalesce(SYNONYMS[w], () => ( []))).map(stem)]));
-  const all = options.toolset ? tools.map((t) => document(t, _nullishCoalesce(setOf.get(t.name), () => ( { name: "", providers: [], tools: [] })))) : docs;
+  const fieldNames = Object.keys(WEIGHTS);
   const idf = /* @__PURE__ */ new Map();
   for (const word of [...words, ...[...alternatives.values()].flat()]) {
     if (idf.has(word)) continue;
-    const df = all.filter((d) => d.all.has(word)).length;
+    const df = all.filter((d) => fieldNames.some((field) => d.fields[field].has(word))).length;
     idf.set(word, Math.log(1 + all.length / (1 + df)));
   }
   const phrase = query.trim().toLowerCase().replace(/\s+/g, "_");
@@ -870,7 +895,7 @@ function searchTools(tools, toolsets, query, options = {}) {
     let matched = 0;
     for (const word of words) {
       let best = 0;
-      for (const field of Object.keys(WEIGHTS)) {
+      for (const field of fieldNames) {
         const weight = COMMON_VERBS.has(word) ? Math.min(WEIGHTS[field], WEIGHTS.description) : WEIGHTS[field];
         const value = matchValue(doc.fields[field], word, _nullishCoalesce(alternatives.get(word), () => ( [])), idf) * weight;
         best = Math.max(best, value);

package/dist/{chunk-67JAEU53.js → chunk-SPPDMY7T.js}

@@ -3,7 +3,7 @@ import {
   TOOL_BRIDGE_PROTOCOL,
   ToolRegistry,
   createMcpServer
-} from "./chunk-SAN4SBBS.js";
+} from "./chunk-ABHOYBZD.js";
 
 // src/bridge/index.ts
 import { createServer } from "http";