@opensip-cli/core 0.1.0

package/dist/languages/parse-cache-class.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-cache-class.js","sourceRoot":"","sources":["../../src/languages/parse-cache-class.ts"],"names":[],"mappings":"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"}

package/dist/languages/parse-cache.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @fileoverview Language-aware parse cache — scope-owned helpers.
+ *
+ * The `LanguageParseCache` class definition lives in `parse-cache-class.ts`
+ * so `RunScope` (which holds a `LanguageParseCache` field) and this module
+ * (which reads `currentScope()`) don't form an import cycle.
+ *
+ * The `initParseCache` / `clearParseCache` / `getParseTree` helpers operate on
+ * the CURRENT RunScope's `parseCache` (`currentScope().parseCache`), NOT a
+ * module-level singleton. This is the scope-isolation fix (audit F2): two
+ * concurrent fit runs (different scopes) carry independent parse caches, and no
+ * process-global cache leaks state between runs or survives a run's teardown.
+ * Outside a `RunScope`, `initParseCache`/`clearParseCache` are no-ops and
+ * `getParseTree` falls back to a direct, uncached parse (single-check mode).
+ *
+ * The `LanguageParseCache` class is still exported for `RunScope` (which
+ * constructs the per-run instance) and for tests/tools that want an isolated
+ * cache.
+ */
+import type { LanguageAdapter } from './adapter.js';
+export { LanguageParseCache } from './parse-cache-class.js';
+/**
+ * Called by FitnessRecipeService before check execution. Clears any stale
+ * entries on the current scope's parse cache and arms its auto-clear timer.
+ * No-op outside a RunScope.
+ */
+export declare function initParseCache(): void;
+/**
+ * Called by FitnessRecipeService after check execution completes. Clears the
+ * current scope's parse cache and stops its auto-clear timer. No-op outside a
+ * RunScope — the scope itself disposes its cache on teardown.
+ */
+export declare function clearParseCache(): void;
+/**
+ * Get or parse the file under the given adapter, using the CURRENT scope's
+ * parse cache. Falls back to a direct (uncached) parse when there is no active
+ * scope (single-check mode).
+ *
+ * Generic over TTree so call sites that already know the language (e.g.
+ * lang-typescript callers passing the TS adapter) get back ts.SourceFile
+ * rather than unknown.
+ */
+export declare function getParseTree<TTree>(adapter: LanguageAdapter<TTree>, filePath: string, content: string): TTree | null;
+/**
+ * Convenience: resolve the adapter for the file via the current scope's
+ * language registry, then parse. Returns null when no adapter is
+ * registered for the extension. Throws when called outside runWithScope —
+ * engine work must run inside a RunScope so adapters resolve via
+ * cli.scope.languages.
+ *
+ * @throws {Error} When called outside a `runWithScope(...)` block (no current scope).
+ */
+export declare function getParseTreeForFile(filePath: string, content: string): unknown;
+//# sourceMappingURL=parse-cache.d.ts.map

package/dist/languages/parse-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-cache.d.ts","sourceRoot":"","sources":["../../src/languages/parse-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAKH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAM5D;;;;GAIG;AACH,wBAAgB,cAAc,IAAI,IAAI,CAKrC;AAED;;;;GAIG;AACH,wBAAgB,eAAe,IAAI,IAAI,CAEtC;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAChC,OAAO,EAAE,eAAe,CAAC,KAAK,CAAC,EAC/B,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,GACd,KAAK,GAAG,IAAI,CAMd;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAkB9E"}

package/dist/languages/parse-cache.js

@@ -0,0 +1,88 @@
+/**
+ * @fileoverview Language-aware parse cache — scope-owned helpers.
+ *
+ * The `LanguageParseCache` class definition lives in `parse-cache-class.ts`
+ * so `RunScope` (which holds a `LanguageParseCache` field) and this module
+ * (which reads `currentScope()`) don't form an import cycle.
+ *
+ * The `initParseCache` / `clearParseCache` / `getParseTree` helpers operate on
+ * the CURRENT RunScope's `parseCache` (`currentScope().parseCache`), NOT a
+ * module-level singleton. This is the scope-isolation fix (audit F2): two
+ * concurrent fit runs (different scopes) carry independent parse caches, and no
+ * process-global cache leaks state between runs or survives a run's teardown.
+ * Outside a `RunScope`, `initParseCache`/`clearParseCache` are no-ops and
+ * `getParseTree` falls back to a direct, uncached parse (single-check mode).
+ *
+ * The `LanguageParseCache` class is still exported for `RunScope` (which
+ * constructs the per-run instance) and for tests/tools that want an isolated
+ * cache.
+ */
+import { logger } from '../lib/logger.js';
+import { currentScope } from '../lib/run-scope.js';
+export { LanguageParseCache } from './parse-cache-class.js';
+// =============================================================================
+// SCOPE-OWNED PARSE-CACHE HELPERS
+// =============================================================================
+/**
+ * Called by FitnessRecipeService before check execution. Clears any stale
+ * entries on the current scope's parse cache and arms its auto-clear timer.
+ * No-op outside a RunScope.
+ */
+export function initParseCache() {
+    const cache = currentScope()?.parseCache;
+    if (!cache)
+        return;
+    cache.clear();
+    cache.startAutoClear();
+}
+/**
+ * Called by FitnessRecipeService after check execution completes. Clears the
+ * current scope's parse cache and stops its auto-clear timer. No-op outside a
+ * RunScope — the scope itself disposes its cache on teardown.
+ */
+export function clearParseCache() {
+    currentScope()?.parseCache.dispose();
+}
+/**
+ * Get or parse the file under the given adapter, using the CURRENT scope's
+ * parse cache. Falls back to a direct (uncached) parse when there is no active
+ * scope (single-check mode).
+ *
+ * Generic over TTree so call sites that already know the language (e.g.
+ * lang-typescript callers passing the TS adapter) get back ts.SourceFile
+ * rather than unknown.
+ */
+export function getParseTree(adapter, filePath, content) {
+    const cache = currentScope()?.parseCache;
+    if (cache) {
+        return cache.getOrParse(adapter, filePath, content);
+    }
+    return adapter.parse(content, filePath);
+}
+/**
+ * Convenience: resolve the adapter for the file via the current scope's
+ * language registry, then parse. Returns null when no adapter is
+ * registered for the extension. Throws when called outside runWithScope —
+ * engine work must run inside a RunScope so adapters resolve via
+ * cli.scope.languages.
+ *
+ * @throws {Error} When called outside a `runWithScope(...)` block (no current scope).
+ */
+export function getParseTreeForFile(filePath, content) {
+    const scope = currentScope();
+    if (!scope) {
+        throw new Error('getParseTreeForFile() called outside runWithScope. ' +
+            'Engine work must run inside a RunScope so language adapters resolve via cli.scope.languages.');
+    }
+    const adapter = scope.languages.forFile(filePath);
+    if (!adapter) {
+        logger.debug({
+            evt: 'lang.parse.no-adapter',
+            module: 'core:languages',
+            filePath,
+        });
+        return null;
+    }
+    return getParseTree(adapter, filePath, content);
+}
+//# sourceMappingURL=parse-cache.js.map

package/dist/languages/parse-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-cache.js","sourceRoot":"","sources":["../../src/languages/parse-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAInD,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAE5D,gFAAgF;AAChF,kCAAkC;AAClC,gFAAgF;AAEhF;;;;GAIG;AACH,MAAM,UAAU,cAAc;IAC5B,MAAM,KAAK,GAAG,YAAY,EAAE,EAAE,UAAU,CAAC;IACzC,IAAI,CAAC,KAAK;QAAE,OAAO;IACnB,KAAK,CAAC,KAAK,EAAE,CAAC;IACd,KAAK,CAAC,cAAc,EAAE,CAAC;AACzB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,eAAe;IAC7B,YAAY,EAAE,EAAE,UAAU,CAAC,OAAO,EAAE,CAAC;AACvC,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,YAAY,CAC1B,OAA+B,EAC/B,QAAgB,EAChB,OAAe;IAEf,MAAM,KAAK,GAAG,YAAY,EAAE,EAAE,UAAU,CAAC;IACzC,IAAI,KAAK,EAAE,CAAC;QACV,OAAO,KAAK,CAAC,UAAU,CAAC,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;IACtD,CAAC;IACD,OAAO,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;AAC1C,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,mBAAmB,CAAC,QAAgB,EAAE,OAAe;IACnE,MAAM,KAAK,GAAG,YAAY,EAAE,CAAC;IAC7B,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,MAAM,IAAI,KAAK,CACb,qDAAqD;YACnD,8FAA8F,CACjG,CAAC;IACJ,CAAC;IACD,MAAM,OAAO,GAAG,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IAClD,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,CAAC,KAAK,CAAC;YACX,GAAG,EAAE,uBAAuB;YAC5B,MAAM,EAAE,gBAAgB;YACxB,QAAQ;SACT,CAAC,CAAC;QACH,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,YAAY,CAAC,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;AAClD,CAAC"}

package/dist/languages/registry.d.ts

@@ -0,0 +1,35 @@
+import type { LanguageAdapter } from './adapter.js';
+/** Per-run registry of language adapters, indexed by id and file extension. */
+export declare class LanguageRegistry {
+    private readonly inner;
+    private readonly byExtension;
+    /**
+     * Alias → canonical id index. Populated alongside the inner registry
+     * during `register`. Lets `canonicalize` map an alias like `'c'` or
+     * `'rs'` back to the registered adapter id (`'cpp'`, `'rust'`).
+     */
+    private readonly aliasIndex;
+    register(adapter: LanguageAdapter): void;
+    private indexExtensions;
+    private indexAliases;
+    get(id: string): LanguageAdapter | undefined;
+    forFile(filePath: string): LanguageAdapter | undefined;
+    /**
+     * Resolve a language id or alias to its canonical adapter id.
+     *
+     * - For a registered canonical id (e.g. `'cpp'`), returns the same id.
+     * - For a registered alias (e.g. `'c'`, `'rs'`, `'golang'`, `'py'`),
+     *   returns the canonical id (`'cpp'`, `'rust'`, `'go'`, `'python'`).
+     * - Returns `undefined` for unknown languages.
+     *
+     * Use this anywhere two pieces of code compare language strings —
+     * scope-matching, target-language sets — so a config written with
+     * `languages: ['c']` matches a check scoped to `cpp`.
+     */
+    canonicalize(idOrAlias: string): string | undefined;
+    list(): readonly LanguageAdapter[];
+    has(id: string): boolean;
+    get size(): number;
+    clear(): void;
+}
+//# sourceMappingURL=registry.d.ts.map

package/dist/languages/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/languages/registry.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAoBpD,+EAA+E;AAC/E,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAInB;IACH,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAsC;IAClE;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA6B;IAExD,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI;IAUxC,OAAO,CAAC,eAAe;IAmBvB,OAAO,CAAC,YAAY;IAkCpB,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAI5C,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAMtD;;;;;;;;;;;OAWG;IACH,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAMnD,IAAI,IAAI,SAAS,eAAe,EAAE;IAIlC,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAIxB,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,KAAK,IAAI,IAAI;CAKd"}

package/dist/languages/registry.js

@@ -0,0 +1,123 @@
+// @fitness-ignore-file batch-operation-limits -- iterates bounded collections (registered language adapters and the small file-extension lookup map)
+import { extname } from 'node:path';
+import { logger } from '../lib/logger.js';
+import { Registry } from '../lib/registry.js';
+/** Per-run registry of language adapters, indexed by id and file extension. */
+export class LanguageRegistry {
+    inner = new Registry({
+        module: 'core:languages',
+        duplicatePolicy: 'warn-first-wins',
+        evtPrefix: 'lang.registry',
+    });
+    byExtension = new Map();
+    /**
+     * Alias → canonical id index. Populated alongside the inner registry
+     * during `register`. Lets `canonicalize` map an alias like `'c'` or
+     * `'rs'` back to the registered adapter id (`'cpp'`, `'rust'`).
+     */
+    aliasIndex = new Map();
+    register(adapter) {
+        const isDuplicate = this.inner.getById(adapter.id) !== undefined;
+        // Inner registry emits the structured warn event on duplicate;
+        // it returns silently after the warn (warn-first-wins policy).
+        this.inner.register({ id: adapter.id, name: adapter.id, adapter });
+        if (isDuplicate)
+            return;
+        this.indexExtensions(adapter);
+        this.indexAliases(adapter);
+    }
+    indexExtensions(adapter) {
+        for (const ext of adapter.fileExtensions) {
+            const normalized = ext.toLowerCase();
+            const existing = this.byExtension.get(normalized);
+            if (existing && existing.id !== adapter.id) {
+                logger.warn({
+                    evt: 'lang.registry.extension.collision',
+                    module: 'core:languages',
+                    extension: normalized,
+                    incumbent: existing.id,
+                    challenger: adapter.id,
+                    msg: `Extension ${normalized} already claimed by ${existing.id} — keeping incumbent`,
+                });
+                continue;
+            }
+            this.byExtension.set(normalized, adapter);
+        }
+    }
+    indexAliases(adapter) {
+        if (!adapter.aliases)
+            return;
+        for (const alias of adapter.aliases) {
+            const normalized = alias.toLowerCase();
+            // An alias that collides with another adapter's canonical id is
+            // ignored — the canonical id always wins. Same for an alias
+            // already claimed by a previously-registered adapter.
+            if (this.inner.getById(normalized) && normalized !== adapter.id) {
+                logger.warn({
+                    evt: 'lang.registry.alias.collision',
+                    module: 'core:languages',
+                    alias: normalized,
+                    incumbent: normalized,
+                    challenger: adapter.id,
+                    msg: `Alias ${normalized} already used as a canonical id — ignoring on ${adapter.id}`,
+                });
+                continue;
+            }
+            const existing = this.aliasIndex.get(normalized);
+            if (existing && existing !== adapter.id) {
+                logger.warn({
+                    evt: 'lang.registry.alias.collision',
+                    module: 'core:languages',
+                    alias: normalized,
+                    incumbent: existing,
+                    challenger: adapter.id,
+                    msg: `Alias ${normalized} already claimed by ${existing} — keeping incumbent`,
+                });
+                continue;
+            }
+            this.aliasIndex.set(normalized, adapter.id);
+        }
+    }
+    get(id) {
+        return this.inner.getById(id)?.adapter;
+    }
+    forFile(filePath) {
+        const ext = extname(filePath).toLowerCase();
+        if (!ext)
+            return undefined;
+        return this.byExtension.get(ext);
+    }
+    /**
+     * Resolve a language id or alias to its canonical adapter id.
+     *
+     * - For a registered canonical id (e.g. `'cpp'`), returns the same id.
+     * - For a registered alias (e.g. `'c'`, `'rs'`, `'golang'`, `'py'`),
+     *   returns the canonical id (`'cpp'`, `'rust'`, `'go'`, `'python'`).
+     * - Returns `undefined` for unknown languages.
+     *
+     * Use this anywhere two pieces of code compare language strings —
+     * scope-matching, target-language sets — so a config written with
+     * `languages: ['c']` matches a check scoped to `cpp`.
+     */
+    canonicalize(idOrAlias) {
+        const normalized = idOrAlias.toLowerCase();
+        if (this.inner.getById(normalized))
+            return normalized;
+        return this.aliasIndex.get(normalized);
+    }
+    list() {
+        return this.inner.getAll().map((r) => r.adapter);
+    }
+    has(id) {
+        return this.inner.getById(id) !== undefined;
+    }
+    get size() {
+        return this.inner.size;
+    }
+    clear() {
+        this.inner.clear();
+        this.byExtension.clear();
+        this.aliasIndex.clear();
+    }
+}
+//# sourceMappingURL=registry.js.map

package/dist/languages/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/languages/registry.ts"],"names":[],"mappings":"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"}

package/dist/languages/strip-scanners.d.ts

@@ -0,0 +1,170 @@
+/**
+ * @fileoverview Language-agnostic scanner primitives for source-stripping
+ * lexers — the lower half of the strip toolkit.
+ *
+ * Every `packages/languages/lang-*` strip.ts composes these primitives into a
+ * language-specific `scan`, which `makeStripper` (in `strip-utils.ts`) turns
+ * into the `{ stripStrings, stripComments }` pair. Each scanner recognizes one
+ * lexical shape (regular string, line/block comment, char literal) and emits
+ * the half-open `Region`s to replace; `applyRegions` overlays them with spaces
+ * while preserving line/column offsets.
+ *
+ * Split out of `strip-utils.ts` so neither file exceeds the file-length limit;
+ * `strip-utils.ts` re-exports everything here, so consumers still import these
+ * from `@opensip-cli/core` (or `strip-utils.js`) unchanged.
+ */
+/** Half-open region `[start, end)` for region-overlay strippers. */
+export interface Region {
+    readonly start: number;
+    readonly end: number;
+}
+/** Result of `scanRegularString`. */
+export interface RegStrResult {
+    /** Index of the closing `"` (or EOF / newline position for unterminated). */
+    readonly contentEnd: number;
+    /** Index after the closing quote — where the outer scanner resumes. */
+    readonly next: number;
+}
+/** Options for `scanRegularString`. */
+export interface ScanRegularStringOptions {
+    /**
+     * When `true`, `\n` is treated as part of the body — the scanner
+     * traverses newlines and only stops at the closing quote or EOF.
+     * Used by Rust regular strings (which can span multiple lines).
+     * Defaults to `false` (matches Java/Go/C++ semantics).
+     */
+    readonly allowMultiline?: boolean;
+}
+/**
+ * Scan a regular double-quoted string starting at `openQuotePos`
+ * (which must reference the opening `"`). Returns the position of the
+ * closing quote and the resume index. Honors backslash escapes (`\"`,
+ * `\\`, `\n`, etc. by simply advancing 2). By default, stops at
+ * unescaped newlines (Java/Go/C++ semantics); pass
+ * `{ allowMultiline: true }` for Rust-style strings that may span
+ * lines.
+ *
+ * If the string is unterminated (no closing quote before newline or
+ * EOF), returns the unterminated position rather than throwing —
+ * callers decide how to handle that case.
+ */
+export declare function scanRegularString(src: string, openQuotePos: number, options?: ScanRegularStringOptions): RegStrResult;
+/** Result of `scanLineComment` and `scanBlockCommentNonNesting`. */
+export interface ScanCommentResult {
+    /**
+     * Index just past the end of the comment region (i.e. the position
+     * where the outer scanner resumes). For line comments without line
+     * continuation this is the position of the terminating newline (or
+     * EOF); for block comments this is the position immediately after
+     * the closing delimiter.
+     */
+    readonly end: number;
+}
+/** Options for `scanLineComment`. */
+export interface ScanLineCommentOptions {
+    /**
+     * When `true`, a `\<newline>` (backslash immediately before a
+     * newline) is a phase-2 line splice — the comment continues onto
+     * the next physical line. Used by C/C++. Defaults to `false`
+     * (matches Java/Go semantics).
+     */
+    readonly allowLineContinuation?: boolean;
+}
+/**
+ * Scan a `//` line comment starting at `start` (which must reference
+ * the first `/` of the opener). Returns the index of the next `\n`
+ * (or EOF) — i.e. where the outer scanner resumes. The returned index
+ * does not include the `\n` itself.
+ *
+ * Pass `{ allowLineContinuation: true }` for C/C++-style line splices:
+ * a `\<newline>` continues the comment onto the next physical line
+ * (per C/C++ phase-2 translation). Defaults to `false`; Java and Go
+ * comments have no such behavior.
+ *
+ * Used by lang-cpp (with `allowLineContinuation: true`), lang-java,
+ * lang-go, lang-rust.
+ */
+export declare function scanLineComment(src: string, start: number, options?: ScanLineCommentOptions): ScanCommentResult;
+/**
+ * Scan a non-nesting block comment starting at `start` (which must
+ * reference the opening slash). Returns the index just past the
+ * closing delimiter — i.e. where the outer scanner resumes. If the
+ * comment is unterminated, returns the EOF position.
+ *
+ * Used by lang-cpp, lang-java, lang-go.
+ */
+export declare function scanBlockCommentNonNesting(src: string, start: number): ScanCommentResult;
+/** Result of `scanBlockCommentNesting`. */
+export interface ScanNestingBlockCommentResult {
+    /** Index just past the closing delimiter (or EOF if unterminated). */
+    readonly end: number;
+    /**
+     * Final depth at scan completion. `0` indicates a balanced (well-
+     * terminated) comment. A positive value indicates an unterminated
+     * comment — `depth` openers were unmatched at EOF.
+     */
+    readonly depth: number;
+}
+/**
+ * Scan a Rust-style nested block comment starting at `start` (which
+ * must reference the opening slash). Each nested opener increments
+ * the depth counter; each closer decrements it. The scan returns when
+ * the depth hits zero (balanced) or when EOF is reached (unterminated
+ * — `depth > 0`).
+ *
+ * Used by lang-rust.
+ */
+export declare function scanBlockCommentNesting(src: string, start: number): ScanNestingBlockCommentResult;
+/** Result of `scanCharLiteral`. */
+export interface ScanCharLiteralResult {
+    /**
+     * Index just past the char literal — i.e. where the outer scanner
+     * resumes. If the close-quote is found within the bound, this is
+     * one past the closing apostrophe. If the literal is unterminated
+     * (overflow or newline), this is one past the opening apostrophe
+     * (the apostrophe is treated as code rather than committing the run
+     * as a literal — see lang-java F2 / lang-cpp F5b).
+     */
+    readonly end: number;
+}
+/** Options for `scanCharLiteral`. */
+export interface ScanCharLiteralOptions {
+    /**
+     * Maximum number of source positions to scan from the opening
+     * quote, inclusive of the close. Defaults to `8` — matches the
+     * lang-java / lang-rust heuristic. lang-cpp overrides this to `12`
+     * to accommodate unicode escapes such as `'\u{1F600}'` (10 chars
+     * including quotes); other C-family adopters should override
+     * similarly when their language permits longer escape sequences.
+     * The scan-cap is permissive: on overflow it recovers by treating
+     * the apostrophe as code.
+     */
+    readonly maxScan?: number;
+}
+/**
+ * Scan a char literal starting at `start` (which must reference the
+ * opening apostrophe). Returns the index just past the literal — or,
+ * if the literal does not close within the scan bound, the index
+ * immediately after the opening apostrophe (the apostrophe is treated
+ * as code rather than committing the consumed run).
+ *
+ * Branch ordering is load-bearing: the escape-sequence advance MUST
+ * run before the close-quote check so escaped-apostrophe char
+ * literals do not terminate at the second apostrophe. See lang-java
+ * F6.
+ *
+ * Used by lang-cpp, lang-java (with prefix-stripping at the call
+ * site), lang-rust (with the lifetime-vs-literal heuristic at the
+ * call site).
+ */
+export declare function scanCharLiteral(src: string, start: number, options?: ScanCharLiteralOptions): ScanCharLiteralResult;
+/**
+ * Replace each region with spaces, preserving newlines and overall
+ * length. Indexes into `src` and out remain identical, so any
+ * line/column derived from the original string is still valid.
+ *
+ * The `Region[]` is treated as readonly; callers may pass either
+ * regions from a comment scan or regions from a string scan (or both).
+ */
+export declare function applyRegions(src: string, regions: readonly Region[]): string;
+//# sourceMappingURL=strip-scanners.d.ts.map

package/dist/languages/strip-scanners.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strip-scanners.d.ts","sourceRoot":"","sources":["../../src/languages/strip-scanners.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,oEAAoE;AACpE,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED,qCAAqC;AACrC,MAAM,WAAW,YAAY;IAC3B,6EAA6E;IAC7E,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,uEAAuE;IACvE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,uCAAuC;AACvC,MAAM,WAAW,wBAAwB;IACvC;;;;;OAKG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;CACnC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,MAAM,EACX,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE,wBAA6B,GACrC,YAAY,CAwBd;AAED,oEAAoE;AACpE,MAAM,WAAW,iBAAiB;IAChC;;;;;;OAMG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED,qCAAqC;AACrC,MAAM,WAAW,sBAAsB;IACrC;;;;;OAKG;IACH,QAAQ,CAAC,qBAAqB,CAAC,EAAE,OAAO,CAAC;CAC1C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,sBAA2B,GACnC,iBAAiB,CAiBnB;AA4BD;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,iBAAiB,CAYxF;AAED,2CAA2C;AAC3C,MAAM,WAAW,6BAA6B;IAC5C,sEAAsE;IACtE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,6BAA6B,CAgBjG;AAED,mCAAmC;AACnC,MAAM,WAAW,qBAAqB;IACpC;;;;;;;OAOG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED,qCAAqC;AACrC,MAAM,WAAW,sBAAsB;IACrC;;;;;;;;;OASG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,sBAA2B,GACnC,qBAAqB,CAuCvB;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAU5E"}