onbuzz 4.9.0 → 4.9.1

package/src/services/embeddings/providers/localProvider.js

@@ -0,0 +1,287 @@
+/**
+ * LocalEmbeddingProvider — fully offline embeddings via Transformers.js
+ * (ONNX Runtime in-process, no Ollama / Python / external daemon).
+ *
+ * Why Transformers.js (not Ollama):
+ *   - Zero external runtime dependency. Users who don't have Ollama,
+ *     LM Studio, or any model runner still get high-quality local
+ *     embeddings out of the box.
+ *   - Pure `npm install @xenova/transformers` — ONNX Runtime ships
+ *     prebuilt binaries for Win/Mac/Linux.
+ *   - Runs in-process: no port, no socket, no IPC. Privacy boundary
+ *     is the OS process.
+ *   - Same model family Ollama would serve (nomic-embed-text), just
+ *     loaded directly via ONNX instead of through a server.
+ *
+ * Model selection:
+ *   - DEFAULT: Xenova/nomic-embed-text-v1.5 — 768-dim, 137M params,
+ *     MTEB ~62.4, 8K context, ~250 MB one-time download. Quality on
+ *     par with text-embedding-3-small. Recommended for most users.
+ *   - SPEED:  Xenova/bge-small-en-v1.5 — 384-dim, 33M params, MTEB
+ *     ~62.2, 512-token context, ~30 MB. Half the index size, ~3x
+ *     faster query. Recommended when corpora are large or hardware
+ *     is modest.
+ *
+ * Both models use task-specific prefixes for queries vs documents
+ * ("search_query: " / "search_document: " for nomic;
+ *  "Represent this sentence for searching relevant passages: " for BGE
+ *  queries — though many users skip this for BGE).
+ *
+ * @xenova/transformers is declared as an OPTIONAL dependency so cloud-only
+ * users don't pay the ~50 MB install cost. If the user selects the local
+ * provider without the package installed, they get a clear remediation
+ * message (NOT_INITIALIZED with install instructions).
+ *
+ * Lazy loading: the model is fetched + initialized on first call,
+ * not at construction. This means:
+ *   - The CLI starts instantly even with local provider configured.
+ *   - First-call latency is ~1-3s for model load + ~50-150ms for
+ *     the actual inference. The orchestrator can pre-warm via a
+ *     dummy call after enable.
+ */
+
+import path from 'path';
+import {
+  EmbeddingProvider,
+  EmbeddingError,
+  EMBEDDING_ERROR_CODES,
+} from '../providerInterface.js';
+
+/**
+ * Known-good local model catalog. New models can be added without
+ * touching consumer code — they'll get auto-discovered dimensions and
+ * the right query/document prefix handling.
+ *
+ * `prefix.query` / `prefix.document` are strings prepended to the
+ * input. `null` means "no prefix" (the model treats both the same).
+ */
+export const LOCAL_MODELS = Object.freeze({
+  'Xenova/nomic-embed-text-v1.5': {
+    dimensions: 768,
+    maxTokensPerText: 8192,
+    prefix: {
+      query:    'search_query: ',
+      document: 'search_document: ',
+    },
+    description: 'Best quality, recommended (250 MB)',
+  },
+  'Xenova/bge-small-en-v1.5': {
+    dimensions: 384,
+    maxTokensPerText: 512,
+    prefix: {
+      // BGE-small's "represent for searching" instruction is only used
+      // for query embeddings — documents stay raw.
+      query:    'Represent this sentence for searching relevant passages: ',
+      document: null,
+    },
+    description: 'Fast, smaller index (30 MB)',
+  },
+  'Xenova/all-MiniLM-L6-v2': {
+    dimensions: 384,
+    maxTokensPerText: 256,
+    prefix: { query: null, document: null },
+    description: 'Classic baseline (25 MB)',
+  },
+});
+
+export const DEFAULT_LOCAL_MODEL = 'Xenova/nomic-embed-text-v1.5';
+
+export class LocalEmbeddingProvider extends EmbeddingProvider {
+  /**
+   * @param {object} opts
+   * @param {string} [opts.modelId]    - Defaults to nomic-embed-text-v1.5.
+   * @param {string} [opts.cacheDir]   - Where Transformers.js stores ONNX
+   *        weights. Defaults to the Transformers.js default; pass an
+   *        absolute path under `.loxia-state/embeddings/cache/` to keep
+   *        downloads scoped to Loxia's state dir.
+   * @param {number} [opts.maxBatchSize=32] - Per-call inference batch
+   *        size. CPU-bound; bigger batches help throughput but increase
+   *        memory pressure. 32 is a safe default on 8 GB RAM laptops.
+   * @param {(modelId: string) => Promise<Function>} [opts.pipelineFactory]
+   *        - Injectable for tests. When supplied, replaces the real
+   *          `@xenova/transformers` dynamic import. The factory must
+   *          return an awaitable pipeline function with signature
+   *          `(input: string|string[], options) => Promise<{tolist():
+   *          number[][] | number[]}>`.
+   * @param {object} [opts.logger]
+   */
+  constructor({
+    modelId = DEFAULT_LOCAL_MODEL,
+    cacheDir = null,
+    maxBatchSize = 32,
+    pipelineFactory = null,
+    logger = null,
+  } = {}) {
+    super();
+    this._modelId = modelId;
+    this._cacheDir = cacheDir;
+    this._maxBatchSize = maxBatchSize;
+    this._pipelineFactory = pipelineFactory;
+    this._logger = logger;
+
+    const known = LOCAL_MODELS[modelId];
+    this._dimensions = known?.dimensions ?? 768;       // safe default
+    this._maxTokensPerText = known?.maxTokensPerText ?? 512;
+    this._prefix = known?.prefix ?? { query: null, document: null };
+
+    // Lazy-load state.
+    this._pipeline = null;
+    this._loadPromise = null;     // dedup concurrent first-call loads
+    this._loadError = null;       // sticky failure so we don't retry every call
+  }
+
+  getInfo() {
+    return {
+      name: 'local',
+      modelId: this._modelId,
+      dimensions: this._dimensions,
+      maxBatchSize: this._maxBatchSize,
+      maxTokensPerText: this._maxTokensPerText,
+      distinguishesQueryAndDocument: !!(this._prefix.query || this._prefix.document),
+      isLocal: true,
+    };
+  }
+
+  /**
+   * Model is loaded? Lightweight — doesn't trigger a load. For first-call
+   * latency hiding, callers should explicitly `await provider.warmup()`.
+   */
+  async health() {
+    if (this._loadError) return { ok: false, reason: this._loadError };
+    if (!this._pipeline) {
+      return { ok: false, reason: `Model "${this._modelId}" not loaded yet. Call warmup() or any embed* method to trigger load.` };
+    }
+    return { ok: true };
+  }
+
+  /**
+   * Force the model load now (downloads on first call, then cached).
+   * Safe to call multiple times — subsequent calls are no-ops.
+   * Throws EmbeddingError on load failure.
+   * @returns {Promise<void>}
+   */
+  async warmup() {
+    await this._ensureLoaded();
+  }
+
+  async _ensureLoaded() {
+    if (this._pipeline) return this._pipeline;
+    if (this._loadError) {
+      throw new EmbeddingError(
+        EMBEDDING_ERROR_CODES.NOT_INITIALIZED,
+        this._loadError,
+        { provider: 'local', transient: false },
+      );
+    }
+    if (this._loadPromise) return this._loadPromise;
+
+    const start = Date.now();
+    this._loadPromise = (async () => {
+      try {
+        const pipe = this._pipelineFactory
+          ? await this._pipelineFactory(this._modelId)
+          : await this._loadRealPipeline();
+        if (typeof pipe !== 'function') {
+          throw new Error('pipelineFactory must return a callable pipeline');
+        }
+        this._pipeline = pipe;
+        this._logger?.info?.('[LocalEmbeddingProvider] Model loaded', {
+          modelId: this._modelId,
+          ms: Date.now() - start,
+        });
+        return pipe;
+      } catch (err) {
+        this._loadError = err?.message || String(err);
+        this._loadPromise = null;
+        if (err instanceof EmbeddingError) throw err;
+        throw new EmbeddingError(
+          EMBEDDING_ERROR_CODES.NOT_INITIALIZED,
+          `Failed to load local model "${this._modelId}": ${this._loadError}`,
+          { provider: 'local', transient: false, cause: err },
+        );
+      }
+    })();
+    return this._loadPromise;
+  }
+
+  async _loadRealPipeline() {
+    let mod;
+    try {
+      // Dynamic import keeps @xenova/transformers an optional dep —
+      // cloud-only users don't pay the install cost.
+      mod = await import('@xenova/transformers');
+    } catch (err) {
+      throw new EmbeddingError(
+        EMBEDDING_ERROR_CODES.NOT_INITIALIZED,
+        '@xenova/transformers is not installed. Run `npm install @xenova/transformers` to use local embeddings, or switch the embedding provider to cloud.',
+        { provider: 'local', transient: false, cause: err },
+      );
+    }
+    const { pipeline, env } = mod;
+    if (this._cacheDir) {
+      // Keep ONNX weights inside Loxia's state dir, not scattered around
+      // the home dir. This makes backups + uninstall clean.
+      env.cacheDir = path.resolve(this._cacheDir);
+    }
+    return await pipeline('feature-extraction', this._modelId);
+  }
+
+  async _embed(texts, kind) {
+    const pipe = await this._ensureLoaded();
+    const prefixed = this._applyPrefix(texts, kind);
+
+    let raw;
+    try {
+      // Transformers.js feature-extraction pipeline signature:
+      //   pipe(input, { pooling, normalize }) -> Tensor
+      // We mean-pool to get one vector per input and skip normalize=true
+      // because the base class normalizes for us (avoids double work +
+      // ensures consistent behavior across providers).
+      raw = await pipe(prefixed, { pooling: 'mean', normalize: false });
+    } catch (err) {
+      throw new EmbeddingError(
+        EMBEDDING_ERROR_CODES.PROVIDER_UNAVAILABLE,
+        `Local pipeline inference failed: ${err?.message || err}`,
+        { provider: 'local', transient: true, cause: err },
+      );
+    }
+
+    // Tensor → JS arrays. Different Tensor shapes:
+    //   - Single input: shape [dim] → tolist() = [n0, n1, ...]
+    //   - Batch input:  shape [batch, dim] → tolist() = [[...], [...], ...]
+    // We always pass an array (even when texts.length === 1) so the
+    // pipeline ALWAYS gives the batch shape — keeps downstream simple.
+    let list;
+    try {
+      list = typeof raw?.tolist === 'function' ? raw.tolist() : raw;
+    } catch (err) {
+      throw new EmbeddingError(
+        EMBEDDING_ERROR_CODES.PROVIDER_UNAVAILABLE,
+        `Failed to materialize pipeline output: ${err?.message || err}`,
+        { provider: 'local', transient: true, cause: err },
+      );
+    }
+
+    // Defensive: if the runtime returned a 1-D array even though we
+    // batched, wrap it. Happens with some Transformers.js versions.
+    if (Array.isArray(list) && list.length > 0 && typeof list[0] === 'number') {
+      list = [list];
+    }
+    return list;
+  }
+
+  /**
+   * Apply the model-specific task prefix. Falls back to identity when the
+   * model doesn't distinguish queries from documents.
+   */
+  _applyPrefix(texts, kind) {
+    const prefix = kind === 'query' ? this._prefix.query : this._prefix.document;
+    if (!prefix) return texts;
+    return texts.map(t => prefix + t);
+  }
+
+  /** Fingerprint includes modelId; vectors get re-embedded on model swap. */
+  getModelFingerprint() {
+    return `local:${this._modelId}`;
+  }
+}

package/src/services/embeddings/providers/openaiProvider.js

@@ -0,0 +1,101 @@
+/**
+ * OpenAIEmbeddingProvider — direct-to-OpenAI BYOK path.
+ *
+ * Unlike AzureEmbeddingProvider (which goes through the Loxia backend),
+ * this provider hits `https://api.openai.com/v1/embeddings` directly using
+ * the user's own OpenAI key from ApiKeyManager.vendorKeys.openai.
+ *
+ * Why both providers: some users want to bring their own OpenAI key
+ * rather than route through Loxia's backend. The Loxia backend doesn't
+ * have to be involved for them. Cost still lands on their OpenAI account.
+ *
+ * Same request/response shape as Azure (it's the OpenAI API in both cases);
+ * the difference is the URL + Authorization header.
+ */
+
+import { EmbeddingProvider, EmbeddingError, EMBEDDING_ERROR_CODES } from '../providerInterface.js';
+import { postEmbeddings, extractOpenAIShape } from './cloudHttpTransport.js';
+
+const DEFAULT_URL = 'https://api.openai.com/v1/embeddings';
+const DEFAULT_MODEL = 'text-embedding-3-small';
+const DEFAULT_DIMS = 1536;
+const DEFAULT_MAX_BATCH = 16;
+const DEFAULT_MAX_TOKENS = 8191;
+
+export class OpenAIEmbeddingProvider extends EmbeddingProvider {
+  /**
+   * @param {object} opts
+   * @param {() => string|null} opts.getApiKey  - Returns current OpenAI key.
+   *        Callback (not stored string) so key rotation in the
+   *        ApiKeyManager is reflected without re-instantiating.
+   * @param {string} [opts.url=DEFAULT_URL] - Override for compat-layer
+   *        proxies (DeepInfra, Together, etc.) that mimic OpenAI's API.
+   * @param {string} [opts.modelId]
+   * @param {number} [opts.dimensions]
+   * @param {number} [opts.maxBatchSize]
+   * @param {number} [opts.timeoutMs]
+   * @param {typeof fetch} [opts.fetchImpl] - Injectable for tests.
+   */
+  constructor({
+    getApiKey,
+    url = DEFAULT_URL,
+    modelId = DEFAULT_MODEL,
+    dimensions = DEFAULT_DIMS,
+    maxBatchSize = DEFAULT_MAX_BATCH,
+    timeoutMs,
+    fetchImpl,
+  } = {}) {
+    super();
+    if (typeof getApiKey !== 'function') {
+      throw new Error('OpenAIEmbeddingProvider requires a getApiKey() callback');
+    }
+    this._url = url;
+    this._getApiKey = getApiKey;
+    this._modelId = modelId;
+    this._dimensions = dimensions;
+    this._maxBatchSize = maxBatchSize;
+    this._timeoutMs = timeoutMs;
+    this._fetchImpl = fetchImpl;
+  }
+
+  getInfo() {
+    return {
+      name: 'openai',
+      modelId: this._modelId,
+      dimensions: this._dimensions,
+      maxBatchSize: this._maxBatchSize,
+      maxTokensPerText: DEFAULT_MAX_TOKENS,
+      distinguishesQueryAndDocument: false,
+      isLocal: false,
+    };
+  }
+
+  async health() {
+    const key = this._getApiKey();
+    if (!key) return { ok: false, reason: 'No OpenAI API key set. Add one under Settings → API Keys.' };
+    return { ok: true };
+  }
+
+  async _embed(texts, _kind) {
+    const apiKey = this._getApiKey();
+    if (!apiKey) {
+      throw new EmbeddingError(
+        EMBEDDING_ERROR_CODES.AUTH_ERROR,
+        'No OpenAI API key set. Add one under Settings → API Keys.',
+        { provider: 'openai', transient: false },
+      );
+    }
+    return postEmbeddings({
+      url: this._url,
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: { input: texts, model: this._modelId },
+      providerName: 'openai',
+      extractVectors: extractOpenAIShape,
+      timeoutMs: this._timeoutMs,
+      fetchImpl: this._fetchImpl,
+    });
+  }
+}

package/src/services/embeddings/utilities/__tests__/textChunker.test.js

@@ -0,0 +1,217 @@
+/**
+ * textChunker tests.
+ *
+ * Pins:
+ *   - Empty / short text → 1 chunk (or 0 for empty)
+ *   - Paragraph boundaries preferred → splits on \n\n when possible
+ *   - Sentence-level fallback when a paragraph is bigger than maxChars
+ *   - Hard slice when even a sentence is too big
+ *   - Overlap between successive chunks (continuity for the model)
+ *   - Offsets are correct so caller can reconstruct
+ *   - No regex (the codebase prefers native string ops)
+ */
+
+import { describe, test, expect } from '@jest/globals';
+import {
+  chunkText,
+  DEFAULT_MAX_CHARS,
+  DEFAULT_OVERLAP_CHARS,
+  estimateTokensChunked,
+} from '../textChunker.js';
+
+describe('chunkText — edge cases', () => {
+  test('empty string returns []', () => {
+    expect(chunkText('')).toEqual([]);
+  });
+
+  test('non-string returns []', () => {
+    expect(chunkText(null)).toEqual([]);
+    expect(chunkText(undefined)).toEqual([]);
+    expect(chunkText(42)).toEqual([]);
+  });
+
+  test('text shorter than maxChars → single chunk, no overlap', () => {
+    const text = 'A short message about telegram dedup.';
+    const chunks = chunkText(text);
+    expect(chunks).toHaveLength(1);
+    expect(chunks[0]).toEqual({
+      text,
+      start: 0,
+      end: text.length,
+      index: 0,
+    });
+  });
+});
+
+describe('chunkText — paragraph packing', () => {
+  test('paragraphs ≤ maxChars are kept together', () => {
+    const text = ['para 1 — short.', 'para 2 — short too.', 'para 3 — also short.'].join('\n\n');
+    const chunks = chunkText(text, { maxChars: 200 });
+    expect(chunks).toHaveLength(1);
+    expect(chunks[0].text).toBe(text);
+  });
+
+  test('multiple chunks split at paragraph boundaries when possible', () => {
+    // Three paragraphs, each ~100 chars; maxChars=120 → each paragraph its own chunk.
+    const p1 = 'A'.repeat(100);
+    const p2 = 'B'.repeat(100);
+    const p3 = 'C'.repeat(100);
+    const text = [p1, p2, p3].join('\n\n');
+    const chunks = chunkText(text, { maxChars: 120, overlapChars: 0 });
+    expect(chunks).toHaveLength(3);
+    // Each chunk should be its paragraph (with separator if not last).
+    expect(chunks[0].text.startsWith(p1)).toBe(true);
+    expect(chunks[1].text.startsWith(p2)).toBe(true);
+    expect(chunks[2].text.startsWith(p3)).toBe(true);
+  });
+
+  test('reconstruction: concatenating chunk text[start:end] equals input', () => {
+    const text = [
+      'First paragraph about telegram dedup floods.',
+      'Second paragraph about the static analysis tool refactor.',
+      'Third paragraph about web tool authentication flow.',
+      'Fourth paragraph about scheduler retry semantics.',
+    ].join('\n\n');
+    const chunks = chunkText(text, { maxChars: 80, overlapChars: 20 });
+    let reconstructed = '';
+    for (const c of chunks) {
+      reconstructed += text.slice(c.start, c.end);
+    }
+    expect(reconstructed).toBe(text);
+  });
+});
+
+describe('chunkText — sentence-level fallback', () => {
+  test('paragraph larger than maxChars splits on sentence boundaries', () => {
+    const sentence = 'This is a sentence about something. ';   // 36 chars
+    const long = sentence.repeat(10);                            // 360 chars
+    const chunks = chunkText(long, { maxChars: 100, overlapChars: 0 });
+    // ~360 / ~100 = 4 chunks, but sentence boundaries make ranges uneven.
+    expect(chunks.length).toBeGreaterThanOrEqual(3);
+    // No chunk should exceed maxChars + overlap.
+    for (const c of chunks) {
+      expect(c.text.length).toBeLessThanOrEqual(100);
+    }
+  });
+
+  test('every sentence boundary type is recognised (.! ? \\n)', () => {
+    // Five "sentences", each ~40 chars, mix of terminators
+    const text = [
+      'Sentence one with a period. ',
+      'Sentence two has an exclamation! ',
+      'Sentence three asks a question? ',
+      'Sentence four uses a newline.\n',
+      'Sentence five is at the end.',
+    ].join('');
+    const chunks = chunkText(text, { maxChars: 80, overlapChars: 0 });
+    // Each chunk ends on a sentence boundary (loose check: ends with one of . ! ? \n or is the final piece)
+    for (let i = 0; i < chunks.length - 1; i++) {
+      const last = chunks[i].text.slice(-2);
+      const endsWell = ['. ', '! ', '? ', '.\n', '!\n', '?\n'].includes(last) || chunks[i].text.endsWith('\n');
+      expect(endsWell).toBe(true);
+    }
+  });
+});
+
+describe('chunkText — hard slicing', () => {
+  test('a single sentence longer than maxChars gets hard-sliced', () => {
+    // Single 1000-char "sentence" with no terminator
+    const blob = 'X'.repeat(1000);
+    const chunks = chunkText(blob, { maxChars: 200, overlapChars: 0 });
+    expect(chunks.length).toBeGreaterThanOrEqual(5);
+    for (const c of chunks) expect(c.text.length).toBeLessThanOrEqual(200);
+  });
+});
+
+describe('chunkText — overlap', () => {
+  test('each non-first chunk begins with content from the prior chunk', () => {
+    const text = [
+      'A'.repeat(80),
+      'B'.repeat(80),
+      'C'.repeat(80),
+      'D'.repeat(80),
+    ].join('\n\n');
+    const chunks = chunkText(text, { maxChars: 100, overlapChars: 30 });
+    expect(chunks.length).toBeGreaterThanOrEqual(2);
+    for (let i = 1; i < chunks.length; i++) {
+      // The text rendered to the model starts with overlap from previous chunk
+      // (the overlap doesn't change the offset bounds — those reflect NEW content).
+      const prevTail = chunks[i - 1].text.slice(-30);
+      expect(chunks[i].text.startsWith(prevTail)).toBe(true);
+    }
+  });
+
+  test('overlap=0 disables overlap', () => {
+    const text = ['A'.repeat(100), 'B'.repeat(100)].join('\n\n');
+    const chunks = chunkText(text, { maxChars: 120, overlapChars: 0 });
+    expect(chunks.length).toBeGreaterThanOrEqual(2);
+    // No prefix from previous chunk
+    expect(chunks[1].text.startsWith('A')).toBe(false);
+  });
+
+  test('overlap is clamped to maxChars - 50 so it never starves the chunk', () => {
+    const text = 'X'.repeat(500);
+    const chunks = chunkText(text, { maxChars: 100, overlapChars: 999 });
+    // Should not infinite-loop or produce zero-content chunks.
+    expect(chunks.length).toBeGreaterThan(0);
+    for (const c of chunks) expect(c.text.length).toBeGreaterThan(0);
+  });
+});
+
+describe('chunkText — defaults', () => {
+  test('default maxChars = 1200, default overlap = 200', () => {
+    expect(DEFAULT_MAX_CHARS).toBe(1200);
+    expect(DEFAULT_OVERLAP_CHARS).toBe(200);
+  });
+
+  test('default sizing handles a typical 4K-char message in 3-4 chunks', () => {
+    const text = 'A typical sentence here. '.repeat(200);   // ~5000 chars
+    const chunks = chunkText(text);                         // defaults
+    expect(chunks.length).toBeGreaterThanOrEqual(3);
+    expect(chunks.length).toBeLessThanOrEqual(6);
+  });
+});
+
+describe('estimateTokensChunked', () => {
+  test('matches the 4-chars-per-token rule', () => {
+    expect(estimateTokensChunked('a'.repeat(4))).toBe(1);
+    expect(estimateTokensChunked('a'.repeat(400))).toBe(100);
+  });
+
+  test('returns 0 for non-string / empty', () => {
+    expect(estimateTokensChunked(null)).toBe(0);
+    expect(estimateTokensChunked('')).toBe(0);
+    expect(estimateTokensChunked(123)).toBe(0);
+  });
+});
+
+describe('chunkText — no regex usage', () => {
+  // Mirror the codebase's "fragile regex" rule from the scheduler refactor:
+  // textChunker.js must only use native string operations.
+  test('source file does not introduce any RegExp literals', async () => {
+    const fs = await import('fs/promises');
+    const url = new URL('../textChunker.js', import.meta.url);
+    const src = await fs.readFile(url, 'utf8');
+    // Strip JS strings + comments to avoid false positives on the word "regex"
+    // appearing inside docs. Cheap heuristic: just count `/` chars used as
+    // regex delimiters. The chunker uses zero — assert that.
+    const lines = src.split('\n').filter(l => !l.trim().startsWith('*') && !l.trim().startsWith('//'));
+    const joined = lines.join('\n');
+    // Look for the typical `/.../g`, `/.../i`, etc. literal pattern.
+    // We allow division operators by requiring at least one regex-flag char
+    // immediately after the closing slash.
+    let foundRegex = false;
+    for (let i = 0; i < joined.length - 2; i++) {
+      if (joined[i] === '/' && joined[i + 1] !== '/' && joined[i + 1] !== '*') {
+        // Try to find matching close slash on same line
+        const newline = joined.indexOf('\n', i);
+        const close = joined.indexOf('/', i + 1);
+        if (close !== -1 && (newline === -1 || close < newline)) {
+          const after = joined[close + 1] || '';
+          if ('gimsuy'.includes(after)) { foundRegex = true; break; }
+        }
+      }
+    }
+    expect(foundRegex).toBe(false);
+  });
+});