@untangle-code/chunker 0.0.0-stage → 0.1.1

package/package.json

@@ -1,6 +1,64 @@
 {
   "name": "@untangle-code/chunker",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.1",
+  "private": false,
+  "type": "module",
+  "description": "Untangle AST chunker: lossless, token-budgeted code chunking with line-fallback and minified strategies (spec.md §8, architecture.md §6.6, §14).",
+  "license": "AGPL-3.0-only",
+  "homepage": "https://github.com/lboel/untangle",
+  "bugs": {
+    "url": "https://github.com/lboel/untangle/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lboel/untangle.git",
+    "directory": "packages/chunker"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": "^22.13.0 || >=24.0.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.test.*",
+    "!dist/**/test-helpers.*",
+    "!dist/**/test-support.*",
+    "!dist/**/test-support/**",
+    "!dist/**/testing/**",
+    "!dist/**/__tests__/**",
+    "src",
+    "!src/**/*.test.ts",
+    "!src/**/test-helpers.ts",
+    "!src/**/test-support.ts",
+    "!src/**/test-support/**",
+    "!src/**/testing/**",
+    "LICENSE",
+    "NOTICE",
+    "README.md",
+    "THIRD_PARTY_LICENSES.md"
+  ],
+  "dependencies": {
+    "@untangle-code/domain": "0.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "22.19.7",
+    "typescript": "5.9.3",
+    "vitest": "3.2.7",
+    "@untangle-code/parser-registry": "0.1.1",
+    "@untangle-code/testkit": "0.1.1"
+  },
+  "scripts": {
+    "build": "node ../../scripts/tsc-build.mjs tsconfig.json",
+    "typecheck": "tsc -p tsconfig.typecheck.json",
+    "test": "vitest run",
+    "clean": "rm -rf dist *.tsbuildinfo"
+  }
 }

package/src/byte-text.ts

@@ -0,0 +1,85 @@
+/**
+ * Byte-accurate text slicing and line/byte conversion (spec.md §7.1's
+ * `SourceRange` convention: byte offsets are 0-based half-open, line numbers
+ * 1-based inclusive).
+ *
+ * The chunker MUST slice chunk content by byte offset, not by JS string
+ * (UTF-16) index, so that `CodeChunkPayloadV1.start_byte`/`end_byte` are
+ * exact and so that content is byte-identical to the source file on disk.
+ * Everything here operates on a `Buffer` built once per file.
+ */
+import type { SourceRange } from "@untangle-code/domain";
+
+/** Precomputed line-start byte offsets for one file's content. */
+export interface LineIndex {
+  buffer: Buffer;
+  /** Byte offset of the first byte of each line; `lineStarts[0] === 0`. */
+  lineStarts: number[];
+}
+
+/** Builds a `LineIndex` from full file content (decoded UTF-8 string). */
+export function buildLineIndex(content: string): LineIndex {
+  const buffer = Buffer.from(content, "utf8");
+  const lineStarts: number[] = [0];
+  for (let i = 0; i < buffer.length; i += 1) {
+    if (buffer[i] === 0x0a) {
+      lineStarts.push(i + 1);
+    }
+  }
+  return { buffer, lineStarts };
+}
+
+/** 1-based line number containing the given 0-based byte offset. */
+export function lineNumberForByteOffset(index: LineIndex, byteOffset: number): number {
+  const { lineStarts } = index;
+  let lo = 0;
+  let hi = lineStarts.length - 1;
+  while (lo < hi) {
+    const mid = Math.ceil((lo + hi) / 2);
+    if (lineStarts[mid]! <= byteOffset) {
+      lo = mid;
+    } else {
+      hi = mid - 1;
+    }
+  }
+  return lo + 1;
+}
+
+/**
+ * Builds a `SourceRange` for a byte span, deriving line numbers from the
+ * index. `endByte` is exclusive; for a non-empty span the end line is the
+ * line containing the last included byte (`endByte - 1`).
+ */
+export function rangeForByteSpan(
+  index: LineIndex,
+  startByte: number,
+  endByte: number,
+): SourceRange {
+  const startLine = lineNumberForByteOffset(index, startByte);
+  const endLine = endByte > startByte ? lineNumberForByteOffset(index, endByte - 1) : startLine;
+  return { startLine, endLine, startByte, endByte };
+}
+
+/** Decodes the UTF-8 bytes `[startByte, endByte)` of the file as a string. */
+export function sliceBytes(index: LineIndex, startByte: number, endByte: number): string {
+  return index.buffer.toString("utf8", startByte, endByte);
+}
+
+/** True if `byte` is a UTF-8 continuation byte (`10xxxxxx`). */
+export function isUtf8ContinuationByte(byte: number): boolean {
+  return (byte & 0b1100_0000) === 0b1000_0000;
+}
+
+/**
+ * Returns the largest offset `<= target` (and `>= 0`) that does not fall in
+ * the middle of a multi-byte UTF-8 sequence, i.e. `buffer[offset]` (if any)
+ * is not a continuation byte. Used to keep token-boundary splits byte-safe
+ * (architecture.md §14.4) even when the file mixes multi-byte characters.
+ */
+export function safeUtf8Boundary(buffer: Buffer, target: number): number {
+  let offset = Math.max(0, Math.min(target, buffer.length));
+  while (offset > 0 && offset < buffer.length && isUtf8ContinuationByte(buffer[offset]!)) {
+    offset -= 1;
+  }
+  return offset;
+}

package/src/chunker.ts

@@ -0,0 +1,142 @@
+/**
+ * Top-level chunking entry point (spec.md §8.3): picks a strategy, runs it,
+ * and — regardless of which strategy ran — guarantees the lossless coverage
+ * invariant (spec.md §8.4) before returning: any residual gap is filled with
+ * `fallback_lines` chunks, then the result is validated one last time and
+ * `ANALYSIS_INCOMPLETE` is thrown if that somehow still fails (defense in
+ * depth; a correct strategy should never leave a gap).
+ */
+import { classifyTextFormat, validateCoverage } from "@untangle-code/domain";
+import type { CodeChunkDraft, CoverageEntry, SourceRange } from "@untangle-code/domain";
+
+import { resolveChunkerConfig } from "./config.js";
+import { contentOf, createBuildContext, emitChunk } from "./context.js";
+import { assertLosslessCoverage, assertTruthfulLedger, chunkedEntry } from "./coverage.js";
+import { detectMinifiedContent } from "./minified-detection.js";
+import { splitByTokenBoundary } from "./split.js";
+import { runAstChunkStrategy } from "./strategies/ast-chunk-strategy.js";
+import { runLineFallbackStrategy } from "./strategies/line-fallback-strategy.js";
+import { runMinifiedStrategy } from "./strategies/minified-strategy.js";
+import type { ChunkDegradation, ChunkFileParams, ChunkFileResult } from "./types.js";
+
+const GAP_HEADER = { signature: "fallback_lines" } as const;
+
+/** Fills any residual byte gap with `fallback_lines` chunks (defense in depth for every strategy). */
+function fillGaps(
+  ctx: ReturnType<typeof createBuildContext>,
+  drafts: CodeChunkDraft[],
+  coverage: CoverageEntry[],
+): void {
+  const gaps = validateCoverage(coverage, ctx.fileRange).gaps;
+  for (const gap of gaps) {
+    const range: SourceRange = { ...gap, startLine: -1, endLine: -1 };
+    for (const piece of splitByTokenBoundary(ctx, range, GAP_HEADER)) {
+      const draft = emitChunk(ctx, {
+        range: piece,
+        content: contentOf(ctx, piece),
+        scopeId: ctx.identity.fileId,
+        chunkKind: "fallback_lines",
+        header: {
+          signature: "fallback_lines",
+          metricsScope: "chunk",
+          metricsScopeId: ctx.identity.fileId,
+        },
+      });
+      drafts.push(draft);
+      coverage.push(chunkedEntry(draft.range, draft.chunkId));
+    }
+  }
+}
+
+/**
+ * Chunks one file per spec.md §8.3: minified detection takes priority over
+ * AST chunking (a minified file may still parse "successfully" but produces
+ * no meaningful symbol structure), then a failed/empty parse falls back to
+ * line windows, and otherwise the AST strategy runs (README "Entscheidungen"
+ * documents this ordering as an Untangle decision — the spec numbers 9/10
+ * as trailing fallback steps without fixing their relative priority).
+ */
+export function chunkFile(params: ChunkFileParams): ChunkFileResult {
+  const config = resolveChunkerConfig(params.config);
+  const ctx = createBuildContext(
+    params.identity,
+    params.content,
+    config,
+    params.parseResult.parseQuality,
+  );
+
+  const isMinified =
+    params.isMinified ??
+    detectMinifiedContent(
+      params.content,
+      config.minifiedDetection,
+      classifyTextFormat(params.identity.filePath),
+    );
+  const hasUsableAst = params.parseResult.parseQuality !== "failed" && params.regions.length > 0;
+
+  let drafts: CodeChunkDraft[];
+  let coverage: CoverageEntry[];
+  let strategy: ChunkFileResult["strategy"];
+  // E4 (WP-165): jede Abweichung von der AST-Strategie bekommt hier einen
+  // benannten Grund. Ohne ihn ist die Abstufung unsichtbar -- die Bytes sind
+  // lueckenlos erfasst, `parseQuality` kann `"complete"` lauten, und trotzdem
+  // hat kein Chunk eine Symbolzuordnung.
+  const degradations: ChunkDegradation[] = [];
+
+  if (isMinified) {
+    const result = runMinifiedStrategy(ctx);
+    drafts = result.drafts;
+    coverage = result.coverage;
+    strategy = "minified";
+    degradations.push({
+      reason: "minified_content",
+      strategy: "minified",
+      detail: `content was classified as minified (${
+        params.isMinified === undefined ? "auto-detected" : "declared by the caller"
+      }), so it was cut into byte windows; no symbol association exists for this file`,
+    });
+  } else if (!hasUsableAst) {
+    const result = runLineFallbackStrategy(ctx);
+    drafts = result.drafts;
+    coverage = result.coverage;
+    strategy = "line_fallback";
+    degradations.push(
+      params.parseResult.parseQuality === "failed"
+        ? {
+            reason: "parse_failed",
+            strategy: "line_fallback",
+            detail: `the parse failed (${String(
+              params.parseResult.errorNodeCount,
+            )} error node(s), ${String(
+              params.parseResult.missingNodeCount,
+            )} missing node(s)), so the file was cut into line windows; no symbol association exists for this file`,
+          }
+        : {
+            reason: "ast_regions_missing",
+            strategy: "line_fallback",
+            detail: `the parse reported "${params.parseResult.parseQuality}" but the language adapter delivered no chunk regions, so the file was cut into line windows; no symbol association exists for this file although the parse claims success`,
+          },
+    );
+  } else {
+    const result = runAstChunkStrategy(ctx, params.regions, params.symbols);
+    drafts = result.drafts;
+    coverage = result.coverage;
+    strategy = "ast";
+  }
+
+  fillGaps(ctx, drafts, coverage);
+  // Two-sided machine check (spec.md §8.4): the ledger must be COMPLETE
+  // (assertLosslessCoverage) and every claim in it must be TRUE
+  // (assertTruthfulLedger) — a synthesized chunk may never stand in for
+  // bytes its content does not literally carry.
+  assertTruthfulLedger(ctx.lineIndex, drafts, coverage, params.identity.filePath);
+  assertLosslessCoverage(coverage, ctx.fileRange, params.identity.filePath);
+
+  return {
+    drafts,
+    coverage,
+    strategy,
+    parseQuality: params.parseResult.parseQuality,
+    degradations,
+  };
+}

package/src/config.ts

@@ -0,0 +1,32 @@
+/**
+ * Default chunker configuration and resolution of caller overrides.
+ */
+import { CHUNKER_VERSION, PARSER_VERSION } from "@untangle-code/domain";
+
+import { DEFAULT_MINIFIED_DETECTION_CONFIG } from "./minified-detection.js";
+import { DEFAULT_TOKEN_ESTIMATOR_CONFIG } from "./token-estimator.js";
+import type { ChunkerConfig, ChunkerConfigInput } from "./types.js";
+
+/**
+ * Untangle decision (README "Entscheidungen"): 800 tokens is the default
+ * per-chunk budget — generous enough for a typical method or a small class
+ * overview, small enough that four to six chunks fit a model's context
+ * alongside a query and other results.
+ */
+export const DEFAULT_MAX_TOKENS_PER_CHUNK = 800;
+
+export const DEFAULT_LINE_FALLBACK_CONFIG = { linesPerChunk: 60, overlapLines: 8 };
+export const DEFAULT_MINIFIED_STRATEGY_CONFIG = { overlapBytes: 0 };
+
+export function resolveChunkerConfig(input: ChunkerConfigInput): ChunkerConfig {
+  return {
+    chunkerVersion: input.chunkerVersion ?? CHUNKER_VERSION,
+    parserVersion: input.parserVersion ?? PARSER_VERSION,
+    maxTokensPerChunk: input.maxTokensPerChunk ?? DEFAULT_MAX_TOKENS_PER_CHUNK,
+    tokenEstimator: input.tokenEstimator ?? DEFAULT_TOKEN_ESTIMATOR_CONFIG,
+    preparedText: input.preparedText,
+    minifiedDetection: input.minifiedDetection ?? DEFAULT_MINIFIED_DETECTION_CONFIG,
+    lineFallback: input.lineFallback ?? DEFAULT_LINE_FALLBACK_CONFIG,
+    minifiedStrategy: input.minifiedStrategy ?? DEFAULT_MINIFIED_STRATEGY_CONFIG,
+  };
+}

package/src/coverage.ts

@@ -0,0 +1,143 @@
+/**
+ * Coverage ledger construction (architecture.md §14.1; spec.md §8.4).
+ *
+ * The validator itself (`validateCoverage`) already lives in
+ * `@untangle-code/domain` as a pure function — it is the shared contract
+ * every producer must satisfy, so it is not redefined here. This module only
+ * builds the ledger entries as chunks are produced, and fills any residual
+ * gap the strategies left behind so the lossless invariant always holds
+ * before a file's chunking result is returned.
+ */
+import type { CodeChunkDraft, CoverageEntry, SourceRange } from "@untangle-code/domain";
+import { UntangleError, validateCoverage } from "@untangle-code/domain";
+
+import { type LineIndex, sliceBytes } from "./byte-text.js";
+
+/** One "chunked" ledger entry for a single emitted chunk. */
+export function chunkedEntry(range: SourceRange, chunkId: string): CoverageEntry {
+  return { range, status: "chunked", chunkIds: [chunkId] };
+}
+
+/** One "excluded" ledger entry; `reason` is mandatory (spec.md §8.4). */
+export function excludedEntry(range: SourceRange, reason: string): CoverageEntry {
+  return { range, status: "excluded", exclusionReason: reason };
+}
+
+/** The chunk fields `assertTruthfulLedger` needs (a structural subset of `CodeChunkDraft`). */
+export type LedgerChunkView = Pick<
+  CodeChunkDraft,
+  "chunkId" | "chunkKind" | "range" | "content" | "synthesized"
+>;
+
+/**
+ * Asserts every ledger claim is TRUE, not merely byte-complete
+ * (spec.md §8.4; docs/BUILD_PLAN.md E4 — no silent masking of content):
+ *
+ * - every NON-synthesized chunk's `content` is byte-exactly the source
+ *   bytes of its `range` (the `CodeChunkDraft.content` contract), so any
+ *   "chunked" entry lying inside such a chunk's range is literally carried;
+ * - every "chunked" entry that is only backed by SYNTHESIZED chunks claims
+ *   nothing beyond what those chunks literally carry: the claimed range's
+ *   text (whitespace-trimmed) must appear verbatim in a claiming chunk's
+ *   content;
+ * - every `chunkIds` reference resolves to an emitted chunk.
+ *
+ * A violation is an error (`UntangleError("ANALYSIS_INCOMPLETE")`), never a
+ * warning: a ledger entry that claims bytes no chunk content carries would
+ * silently mask content exactly as spec.md §8.4 forbids.
+ */
+export function assertTruthfulLedger(
+  lineIndex: LineIndex,
+  drafts: readonly LedgerChunkView[],
+  entries: readonly CoverageEntry[],
+  filePath: string,
+): void {
+  const violations: string[] = [];
+  const byId = new Map<string, LedgerChunkView>();
+  for (const draft of drafts) {
+    byId.set(draft.chunkId, draft);
+  }
+
+  for (const draft of drafts) {
+    if (draft.synthesized === true) {
+      continue;
+    }
+    const sourceText = sliceBytes(lineIndex, draft.range.startByte, draft.range.endByte);
+    if (draft.content !== sourceText) {
+      violations.push(
+        `non-synthesized ${draft.chunkKind} chunk ${draft.chunkId} content is not byte-exact for its range ${draft.range.startByte}..${draft.range.endByte}`,
+      );
+    }
+  }
+
+  for (const entry of entries) {
+    if (entry.status !== "chunked") {
+      continue;
+    }
+    const claimedTrimmed = sliceBytes(lineIndex, entry.range.startByte, entry.range.endByte).trim();
+    let proven = false;
+    for (const chunkId of entry.chunkIds ?? []) {
+      const draft = byId.get(chunkId);
+      if (draft === undefined) {
+        violations.push(
+          `chunked entry ${entry.range.startByte}..${entry.range.endByte} references unknown chunk ${chunkId}`,
+        );
+        continue;
+      }
+      if (draft.synthesized !== true) {
+        // Content is byte-exact (checked above), so containment of the
+        // claimed byte range in the chunk range proves the claim literally.
+        if (
+          draft.range.startByte <= entry.range.startByte &&
+          entry.range.endByte <= draft.range.endByte
+        ) {
+          proven = true;
+          break;
+        }
+      } else if (draft.content.includes(claimedTrimmed)) {
+        proven = true;
+        break;
+      }
+    }
+    if (!proven) {
+      violations.push(
+        `chunked entry ${entry.range.startByte}..${entry.range.endByte} claims bytes none of its chunks [${(entry.chunkIds ?? []).join(", ")}] literally carries`,
+      );
+    }
+  }
+
+  if (violations.length > 0) {
+    throw new UntangleError(
+      "ANALYSIS_INCOMPLETE",
+      `coverage ledger of "${filePath}" claims content its chunks do not literally carry (spec.md §8.4)`,
+      {
+        operation: "chunker.assertTruthfulLedger",
+        context: { filePath, violations },
+      },
+    );
+  }
+}
+
+/**
+ * Asserts the lossless invariant holds for `entries` over `fileRange`, or
+ * throws `UntangleError("ANALYSIS_INCOMPLETE")` naming the concrete gaps
+ * (spec.md §8.4: hard truncation without a follow-up chunk is a bug, not a
+ * warning). Every chunking strategy MUST call this before returning.
+ */
+export function assertLosslessCoverage(
+  entries: readonly CoverageEntry[],
+  fileRange: SourceRange,
+  filePath: string,
+): void {
+  const result = validateCoverage(entries, fileRange);
+  if (!result.complete) {
+    throw new UntangleError(
+      "ANALYSIS_INCOMPLETE",
+      `chunking left the source of "${filePath}" incompletely covered (spec.md §8.4)`,
+      {
+        operation: "chunker.assertLosslessCoverage",
+        context: { filePath, gaps: result.gaps, issues: result.issues },
+      },
+    );
+  }
+}

package/src/index.ts

@@ -0,0 +1,63 @@
+/**
+ * @untangle-code/chunker — lossless, token-budgeted AST chunking
+ * (spec.md §8, architecture.md §6.6 and §14).
+ *
+ * The only public export of this package. Consumers pass in what a
+ * `LanguageAdapter` (from `@untangle-code/domain`, implemented by
+ * `parser-registry`) already produced — `ParseResult`, `AstRegion[]`,
+ * `ExtractedSymbol[]` — plus file identity and raw content, and get back
+ * `CodeChunkDraft[]` ready for embedding and storage.
+ */
+
+// Main entry point (spec.md §8.3)
+export { chunkFile } from "./chunker.js";
+
+// Configuration
+export {
+  DEFAULT_LINE_FALLBACK_CONFIG,
+  DEFAULT_MAX_TOKENS_PER_CHUNK,
+  DEFAULT_MINIFIED_STRATEGY_CONFIG,
+  resolveChunkerConfig,
+} from "./config.js";
+// E4-Abstufungsledger (WP-165): warum die AST-Strategie nicht lief.
+export { CHUNK_DEGRADATION_REASONS } from "./types.js";
+export type {
+  ChunkDegradation,
+  ChunkDegradationReason,
+  ChunkerConfig,
+  ChunkerConfigInput,
+  ChunkFileIdentity,
+  ChunkFileParams,
+  ChunkFileResult,
+  LineFallbackConfig,
+  MinifiedStrategyConfig,
+} from "./types.js";
+
+// Token estimation (architecture.md §14.4) — exposed so callers can budget
+// consistently, e.g. when deciding how many chunks fit a query context.
+export { DEFAULT_TOKEN_ESTIMATOR_CONFIG, estimateTokens } from "./token-estimator.js";
+export type { TokenEstimatorConfig } from "./token-estimator.js";
+
+// Minified-content detection (spec.md §8.3 step 10) — exposed so a scanner
+// can pre-classify files without re-implementing the heuristic.
+export { DEFAULT_MINIFIED_DETECTION_CONFIG, detectMinifiedContent } from "./minified-detection.js";
+export type { MinifiedDetectionConfig } from "./minified-detection.js";
+
+// Prepared text builder (spec.md §8.6)
+export {
+  buildBm25Text,
+  buildBm25TextForDraft,
+  buildPreparedDenseText,
+  buildPreparedDenseTextForDraft,
+} from "./prepared-text.js";
+export type { Bm25TextMeta, PreparedTextContext, PreparedTextMeta } from "./prepared-text.js";
+
+// Coverage ledger helpers (architecture.md §14.1; spec.md §8.4) — the
+// validator itself is `validateCoverage` from `@untangle-code/domain`.
+export {
+  assertLosslessCoverage,
+  assertTruthfulLedger,
+  chunkedEntry,
+  excludedEntry,
+} from "./coverage.js";
+export type { LedgerChunkView } from "./coverage.js";

package/src/minified-detection.ts

@@ -0,0 +1,66 @@
+/**
+ * Minified-content detection (spec.md §8.3 step 10).
+ *
+ * Untangle decision (documented in README "Entscheidungen"): minification is
+ * detected from the raw text alone, BEFORE looking at parse results, because
+ * minified code can parse perfectly well while still being useless for
+ * per-symbol AST chunking (a bundled `.min.js` often has its entire runtime
+ * as one statement on one line). Detection is a simple, explainable
+ * character-shape heuristic — no dependency on a bundler manifest or file
+ * name convention, since generated output does not always carry one.
+ */
+
+import { DEFAULT_MINIFIED_RULE, isMinifiedShape } from "@untangle-code/domain";
+import type { TextFormatKind } from "@untangle-code/domain";
+
+export interface MinifiedDetectionConfig {
+  /** Below this file size (bytes), never classify as minified (avoids false positives on tiny files). */
+  minSizeBytes: number;
+  /** Average bytes-per-line at or above which content is considered minified. */
+  avgLineLengthThreshold: number;
+  /** A single long line is sufficient only for structured data, not code or prose. */
+  maxLineLengthThreshold: number;
+}
+
+export const DEFAULT_MINIFIED_DETECTION_CONFIG: MinifiedDetectionConfig = {
+  minSizeBytes: 2000,
+  avgLineLengthThreshold: 300,
+  // Welle 13: von 1000 auf 500 angeglichen. Der Scanner entschied ohnehin bei
+  // 500, und im Indexpfad kam dieser Wert nie zum Zug — zwei Schwellen fuer
+  // eine Frage waren der Fehler, nicht die eine oder die andere Zahl.
+  maxLineLengthThreshold: DEFAULT_MINIFIED_RULE.maxLineLengthThreshold,
+};
+
+/**
+ * Heuristically classifies `content` as minified. Pure, deterministic,
+ * offline — no tokenizer, no bundler introspection.
+ */
+export function detectMinifiedContent(
+  content: string,
+  config: MinifiedDetectionConfig = DEFAULT_MINIFIED_DETECTION_CONFIG,
+  textFormat?: TextFormatKind | null,
+): boolean {
+  const size = Buffer.byteLength(content, "utf8");
+  if (size < config.minSizeBytes) {
+    return false;
+  }
+  const lines = content.split("\n");
+  let maxLineLength = 0;
+  for (const line of lines) {
+    if (line.length > maxLineLength) {
+      maxLineLength = line.length;
+    }
+  }
+  // Entschieden wird in `@untangle-code/domain`: dieselbe Frage darf nicht an
+  // zwei Orten mit zwei Schwellen beantwortet werden. Bis Welle 13 galt hier
+  // 1000 und im Scanner 500 — welche Regel griff, hing am Aufrufpfad.
+  const avgLineLength = content.length / lines.length;
+  return isMinifiedShape(
+    { maxLineLength, averageLineLength: avgLineLength },
+    { textFormat: textFormat ?? null },
+    {
+      maxLineLengthThreshold: config.maxLineLengthThreshold,
+      averageLineLengthThreshold: config.avgLineLengthThreshold,
+    },
+  );
+}