peaks-loop 4.0.53 → 4.1.0

package/dist/services/sc/sc-service.js

@@ -67,9 +67,14 @@ function getCurrentCommitHash(workspaceRoot) {
     if (!workspaceRoot)
         return null;
     try {
-        return execFileSync('git', ['rev-parse', 'HEAD'], { cwd: workspaceRoot, encoding: 'utf-8', windowsHide: true }).trim();
+        return execFileSync('git', ['rev-parse', 'HEAD'], {
+            cwd: workspaceRoot,
+            encoding: 'utf-8',
+            windowsHide: true
+        }).trim();
     }
-    catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+    catch {
+        // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
         return null;
     }
 }
@@ -117,11 +122,11 @@ function isRetainedArtifactFile(filePath, artifactWorkspacePath, changesRoot, ch
         const changesRootRealPath = realpathSync(changesRoot);
         const changeDirRealPath = realpathSync(changeDir);
         const fileRealPath = realpathSync(filePath);
-        return !lstatSync(changesRoot).isSymbolicLink()
-            && !lstatSync(changeDir).isSymbolicLink()
-            && isInsidePath(changesRootRealPath, artifactWorkspaceRealPath)
-            && isInsidePath(changeDirRealPath, changesRootRealPath)
-            && isInsidePath(fileRealPath, changeDirRealPath);
+        return (!lstatSync(changesRoot).isSymbolicLink() &&
+            !lstatSync(changeDir).isSymbolicLink() &&
+            isInsidePath(changesRootRealPath, artifactWorkspaceRealPath) &&
+            isInsidePath(changeDirRealPath, changesRootRealPath) &&
+            isInsidePath(fileRealPath, changeDirRealPath));
     }
     catch {
         return false;
@@ -178,7 +183,8 @@ function readSessionJsonBinding(projectRoot) {
             return parsed.sessionId;
         }
     }
-    catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+    catch {
+        // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
         return null;
     }
     return null;
@@ -227,7 +233,8 @@ function findSessionOwningSlice(projectRoot, sliceId) {
     try {
         topLevel = readdirSync(peaksRoot);
     }
-    catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+    catch {
+        // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
         return null;
     }
     topLevel.sort();
@@ -327,7 +334,10 @@ export function resolveArtifactSession(projectRoot, sliceId) {
     }
     const findHit = findSessionOwningSlice(projectRoot, sliceId);
     if (findHit !== null) {
-        return { resolvedSessionId: findHit, candidateSources: ['active-skill', 'session-json', 'find-fallback'] };
+        return {
+            resolvedSessionId: findHit,
+            candidateSources: ['active-skill', 'session-json', 'find-fallback']
+        };
     }
     return { resolvedSessionId: null, candidateSources: [] };
 }
@@ -345,7 +355,9 @@ export function getChangeTraceabilityStatus() {
                 path: resolve('.peaks', '<session-id>', ...artifact.path),
                 exists: false
             })),
-            nextActions: ['Add a workspace: peaks config workspace add --id <id> --name <name> --path <path>']
+            nextActions: [
+                'Add a workspace: peaks config workspace add --id <id> --name <name> --path <path>'
+            ]
         };
     }
     const artifactWorkspacePath = getLocalArtifactPath(workspace);
@@ -448,7 +460,9 @@ export function validateArtifactRetention(sliceId) {
         return {
             valid: false,
             missingArtifacts: ['Invalid slice id'],
-            warnings: ['Slice id must stay inside .peaks/_runtime/<session-id> and only contain letters, numbers, dots, underscores, or hyphens'],
+            warnings: [
+                'Slice id must stay inside .peaks/_runtime/<session-id> and only contain letters, numbers, dots, underscores, or hyphens'
+            ],
             resolvedSessionId: null,
             candidateSources: []
         };
@@ -506,9 +520,8 @@ export function validateArtifactRetention(sliceId) {
             candidateSources: resolution.candidateSources
         };
     }
-    const missingArtifacts = RETENTION_REQUIREMENTS
-        .map(([folder, file]) => `${folder}/${file}`)
-        .filter((rel) => !legacyPresent(...rel.split('/')) && !resolvedPresent(...rel.split('/')));
+    const missingArtifacts = RETENTION_REQUIREMENTS.map(([folder, file]) => `${folder}/${file}`).filter((rel) => !legacyPresent(...rel.split('/')) &&
+        !resolvedPresent(...rel.split('/')));
     // If the legacy check is short (i.e. we're missing a lot of legacy-named
     // files) but the resolver landed on a real session, ALSO accept the
     // modern set. The legacy set was designed for an older workflow naming

package/dist/services/scan/acceptance-coverage-service.js

@@ -56,7 +56,10 @@ function extractTestCases(qaBody) {
             continue;
         const acceptanceMatch = ACCEPTANCE_FIELD_PATTERN.exec(raw);
         if (acceptanceMatch !== null) {
-            const refs = (acceptanceMatch[1] ?? '').split(/[,\s]+/).map((part) => part.trim()).filter((part) => part.length > 0);
+            const refs = (acceptanceMatch[1] ?? '')
+                .split(/[,\s]+/)
+                .map((part) => part.trim())
+                .filter((part) => part.length > 0);
             current.ids.push(...refs);
         }
     }

package/dist/services/scan/api-diff-openapi-schema-read.d.ts

@@ -0,0 +1,67 @@
+/**
+ * api-diff-openapi-schema-read — the schema-node readers behind
+ * `api-diff-openapi.ts`.
+ *
+ * Hoisted verbatim by the wave-5 file-size split
+ * (rid 2026-10-01-wave5-w5-2-slice-scan): the `$ref` / composition primitives a
+ * schema node is read with, the flat-field-set constants, the content and
+ * parameter accessors, and `loadApiDocument` (which the parent re-exports so
+ * `./api-diff-openapi.js` stays the public import path). The analysis that
+ * *judges* a document — `schemaToTypeString`, `collectFields`,
+ * `parseOpenApiDocument`, `splitTopLevel`, `normalizeType` — stays in the
+ * parent, because those carry the file's lint findings.
+ *
+ * The parent <-> sibling import is a deliberate cycle, safe under
+ * `module: NodeNext`: every cross-boundary reference is a hoisted function
+ * declaration read at call time, never at module init (lint-gate.md 4e).
+ */
+import { type ParsedDocument } from './api-diff-types.js';
+/**
+ * OpenAPI scalar types mapped to their TypeScript spelling. `integer` is NOT a
+ * TypeScript type — an unmapped `integer` produced a false `number -> integer`
+ * exact line against a recorded `id: number`.
+ */
+declare const SCALAR_TYPES: Readonly<Record<string, string>>;
+declare const COMPOSITION_KEYS: readonly ["allOf", "oneOf", "anyOf"];
+declare function refName(ref: string): string;
+/** Resolves a `$ref` chain. Callers that only need the NAME must not use this — see `schemaToTypeString`. */
+declare function deref(schema: unknown, doc: Record<string, unknown>, depth: number): Record<string, unknown> | null;
+/** The composition/open-shape construct a schema node carries, if any — those cannot be flattened without a compiler. */
+declare function unreadableConstruct(node: Record<string, unknown>): string | null;
+export { COMPOSITION_KEYS, deref, refName, SCALAR_TYPES, unreadableConstruct };
+type SchemaRead = {
+    fields: Map<string, string>;
+    incompleteReason: string | null;
+};
+/**
+ * Flat leaf fields of a body/response schema. Arrays descend one level into
+ * `items`. The ROOT `$ref` is resolved on purpose — a top-level `$ref` response
+ * IS the interface — while nested refs stay named (see `schemaToTypeString`).
+ *
+ * A node carrying `allOf`/`oneOf`/`anyOf` or `additionalProperties` alongside its
+ * own `properties` is INCOMPLETE: the sibling properties made the location look
+ * non-empty, so there was neither suppression nor a note, and a field declared
+ * under `allOf` was reported as an exact `-> (absent)`.
+ */
+declare const UNRESOLVED_REF = "its schema is a `$ref` chain deeper than the reader resolves";
+declare const NO_PROPERTIES = "its schema lists no `properties`, so no field set could be read from it";
+export { NO_PROPERTIES, type SchemaRead, UNRESOLVED_REF };
+declare function jsonContent(content: unknown): unknown;
+declare function schemaOf(media: unknown): unknown;
+/**
+ * The `parameters` array of an OpenAPI object, or `[]` when absent.
+ *
+ * S10 (2026-09-20): the call sites used to inline
+ * `Array.isArray(x['parameters']) ? x['parameters'] : []`, and because
+ * `Array.isArray` is typed `arg is any[]` the ternary's type was `any[]` —
+ * which then flowed into `collectParameters`. Returning `readonly unknown[]`
+ * stops the `any` at this function boundary without asserting anything about
+ * the elements: `collectParameters` already narrows each entry itself
+ * (`Array.isArray` + `isRecord`), and that is the only place that knows what a
+ * parameter may contain.
+ */
+declare function parametersOf(record: Record<string, unknown>): readonly unknown[];
+declare function collectParameters(parameters: unknown, locations: Map<string, Map<string, string>>): void;
+export { collectParameters, jsonContent, parametersOf, schemaOf };
+/** Reads and parses `.json` / `.yaml` / `.yml`. Throws `ApiDiffInputError` on anything else. */
+export declare function loadApiDocument(file: string): ParsedDocument;

package/dist/services/scan/api-diff-openapi-schema-read.js

@@ -0,0 +1,154 @@
+/**
+ * api-diff-openapi-schema-read — the schema-node readers behind
+ * `api-diff-openapi.ts`.
+ *
+ * Hoisted verbatim by the wave-5 file-size split
+ * (rid 2026-10-01-wave5-w5-2-slice-scan): the `$ref` / composition primitives a
+ * schema node is read with, the flat-field-set constants, the content and
+ * parameter accessors, and `loadApiDocument` (which the parent re-exports so
+ * `./api-diff-openapi.js` stays the public import path). The analysis that
+ * *judges* a document — `schemaToTypeString`, `collectFields`,
+ * `parseOpenApiDocument`, `splitTopLevel`, `normalizeType` — stays in the
+ * parent, because those carry the file's lint findings.
+ *
+ * The parent <-> sibling import is a deliberate cycle, safe under
+ * `module: NodeNext`: every cross-boundary reference is a hoisted function
+ * declaration read at call time, never at module init (lint-gate.md 4e).
+ */
+import { readFileSync } from 'node:fs';
+import { parse as parseYaml } from 'yaml';
+import { ApiDiffInputError, isRecord } from './api-diff-types.js';
+import { parseOpenApiDocument, schemaToTypeString } from './api-diff-openapi.js';
+const MAX_REF_DEPTH = 4;
+/**
+ * OpenAPI scalar types mapped to their TypeScript spelling. `integer` is NOT a
+ * TypeScript type — an unmapped `integer` produced a false `number -> integer`
+ * exact line against a recorded `id: number`.
+ */
+const SCALAR_TYPES = {
+    string: 'string',
+    number: 'number',
+    integer: 'number',
+    boolean: 'boolean'
+};
+const COMPOSITION_KEYS = ['allOf', 'oneOf', 'anyOf'];
+function refName(ref) {
+    const tail = ref.slice(ref.lastIndexOf('/') + 1);
+    return tail.length > 0 ? tail : ref;
+}
+/** Resolves a `$ref` chain. Callers that only need the NAME must not use this — see `schemaToTypeString`. */
+function deref(schema, doc, depth) {
+    if (!isRecord(schema))
+        return null;
+    const ref = schema['$ref'];
+    if (typeof ref === 'string' && depth < MAX_REF_DEPTH) {
+        let node = doc;
+        for (const part of ref.replace(/^#\//, '').split('/')) {
+            if (!isRecord(node))
+                return null;
+            node = node[part];
+        }
+        return deref(node, doc, depth + 1);
+    }
+    return schema;
+}
+/** The composition/open-shape construct a schema node carries, if any — those cannot be flattened without a compiler. */
+function unreadableConstruct(node) {
+    for (const key of COMPOSITION_KEYS) {
+        const value = node[key];
+        if (Array.isArray(value) && value.length > 0) {
+            return `it composes schemas with \`${key}\`, which cannot be flattened here`;
+        }
+    }
+    const additional = node['additionalProperties'];
+    if (additional !== undefined && additional !== false) {
+        return 'it declares `additionalProperties`, so it may carry fields it does not list';
+    }
+    return null;
+}
+export { COMPOSITION_KEYS, deref, refName, SCALAR_TYPES, unreadableConstruct };
+/**
+ * Flat leaf fields of a body/response schema. Arrays descend one level into
+ * `items`. The ROOT `$ref` is resolved on purpose — a top-level `$ref` response
+ * IS the interface — while nested refs stay named (see `schemaToTypeString`).
+ *
+ * A node carrying `allOf`/`oneOf`/`anyOf` or `additionalProperties` alongside its
+ * own `properties` is INCOMPLETE: the sibling properties made the location look
+ * non-empty, so there was neither suppression nor a note, and a field declared
+ * under `allOf` was reported as an exact `-> (absent)`.
+ */
+const UNRESOLVED_REF = 'its schema is a `$ref` chain deeper than the reader resolves';
+const NO_PROPERTIES = 'its schema lists no `properties`, so no field set could be read from it';
+export { NO_PROPERTIES, UNRESOLVED_REF };
+function jsonContent(content) {
+    if (!isRecord(content))
+        return undefined;
+    if (content['application/json'] !== undefined)
+        return content['application/json'];
+    return Object.values(content)[0];
+}
+function schemaOf(media) {
+    return isRecord(media) ? media['schema'] : undefined;
+}
+/**
+ * The `parameters` array of an OpenAPI object, or `[]` when absent.
+ *
+ * S10 (2026-09-20): the call sites used to inline
+ * `Array.isArray(x['parameters']) ? x['parameters'] : []`, and because
+ * `Array.isArray` is typed `arg is any[]` the ternary's type was `any[]` —
+ * which then flowed into `collectParameters`. Returning `readonly unknown[]`
+ * stops the `any` at this function boundary without asserting anything about
+ * the elements: `collectParameters` already narrows each entry itself
+ * (`Array.isArray` + `isRecord`), and that is the only place that knows what a
+ * parameter may contain.
+ */
+function parametersOf(record) {
+    const value = record['parameters'];
+    return Array.isArray(value) ? value : [];
+}
+function collectParameters(parameters, locations) {
+    if (!Array.isArray(parameters))
+        return;
+    for (const raw of parameters) {
+        if (!isRecord(raw))
+            continue;
+        const where = raw['in'];
+        const name = raw['name'];
+        if (where !== 'path' && where !== 'query')
+            continue;
+        if (typeof name !== 'string')
+            continue;
+        const key = where === 'path' ? 'pathParams' : 'queryParams';
+        const bucket = locations.get(key) ?? new Map();
+        bucket.set(name, schemaToTypeString(raw['schema'], {}, 0));
+        locations.set(key, bucket);
+    }
+}
+export { collectParameters, jsonContent, parametersOf, schemaOf };
+/** Reads and parses `.json` / `.yaml` / `.yml`. Throws `ApiDiffInputError` on anything else. */
+export function loadApiDocument(file) {
+    let raw;
+    try {
+        raw = readFileSync(file, 'utf8');
+    }
+    catch (error) {
+        throw new ApiDiffInputError('UNREADABLE', `cannot read ${file}: ${error.message}`);
+    }
+    const lower = file.toLowerCase();
+    let parsed;
+    try {
+        if (lower.endsWith('.yaml') || lower.endsWith('.yml'))
+            parsed = parseYaml(raw);
+        else if (lower.endsWith('.json') || raw.trimStart().startsWith('{'))
+            parsed = JSON.parse(raw);
+        else
+            parsed = parseYaml(raw);
+    }
+    catch (error) {
+        throw new ApiDiffInputError('PARSE_FAILED', `cannot parse ${file} as JSON or YAML: ${error.message}`);
+    }
+    if (!isRecord(parsed)) {
+        throw new ApiDiffInputError('NOT_AN_OBJECT', `${file} did not parse to an object`);
+    }
+    return parseOpenApiDocument(file, parsed);
+}

package/dist/services/scan/api-diff-openapi.d.ts

@@ -14,9 +14,23 @@
  * never presented as complete.
  */
 import { type ParsedDocument } from './api-diff-types.js';
+import { loadApiDocument } from './api-diff-openapi-schema-read.js';
+export { loadApiDocument };
+/**
+ * Renders an OpenAPI schema as a TypeScript-ish type text. Arrays render as
+ * `Array<X>` (not `X[]`) on purpose: `normalizeType` rewrites both sides
+ * identically, so a recorded `X[]` and a document `Array<X>` still compare equal.
+ *
+ * A `$ref` is answered with its referenced NAME and never dereferenced. Checking
+ * after `deref()` made `refName` unreachable for every ref inside
+ * `MAX_REF_DEPTH`, so a nested `owner: {$ref: User}` was reported as `object`
+ * against a recorded `owner: User` — an exact line for a field that did not
+ * change. The name is the faithful reading, and it is what a recorded interface
+ * writes.
+ */
+declare function schemaToTypeString(schema: unknown, doc: Record<string, unknown>, depth: number): string;
+export { schemaToTypeString };
 export declare function parseOpenApiDocument(file: string, doc: Record<string, unknown>): ParsedDocument;
-/** Reads and parses `.json` / `.yaml` / `.yml`. Throws `ApiDiffInputError` on anything else. */
-export declare function loadApiDocument(file: string): ParsedDocument;
 /**
  * Normalizes type text so `Array<string>`, `string[]`, `string | null` and
  * `string|null` compare equal.

package/dist/services/scan/api-diff-openapi.js

@@ -13,56 +13,9 @@
  * incomplete, which suppresses every exact line for that location. Partial is
  * never presented as complete.
  */
-import { readFileSync } from 'node:fs';
-import { parse as parseYaml } from 'yaml';
 import { ApiDiffInputError, HTTP_METHODS, isRecord } from './api-diff-types.js';
-const MAX_REF_DEPTH = 4;
-/**
- * OpenAPI scalar types mapped to their TypeScript spelling. `integer` is NOT a
- * TypeScript type — an unmapped `integer` produced a false `number -> integer`
- * exact line against a recorded `id: number`.
- */
-const SCALAR_TYPES = {
-    string: 'string',
-    number: 'number',
-    integer: 'number',
-    boolean: 'boolean'
-};
-const COMPOSITION_KEYS = ['allOf', 'oneOf', 'anyOf'];
-function refName(ref) {
-    const tail = ref.slice(ref.lastIndexOf('/') + 1);
-    return tail.length > 0 ? tail : ref;
-}
-/** Resolves a `$ref` chain. Callers that only need the NAME must not use this — see `schemaToTypeString`. */
-function deref(schema, doc, depth) {
-    if (!isRecord(schema))
-        return null;
-    const ref = schema['$ref'];
-    if (typeof ref === 'string' && depth < MAX_REF_DEPTH) {
-        let node = doc;
-        for (const part of ref.replace(/^#\//, '').split('/')) {
-            if (!isRecord(node))
-                return null;
-            node = node[part];
-        }
-        return deref(node, doc, depth + 1);
-    }
-    return schema;
-}
-/** The composition/open-shape construct a schema node carries, if any — those cannot be flattened without a compiler. */
-function unreadableConstruct(node) {
-    for (const key of COMPOSITION_KEYS) {
-        const value = node[key];
-        if (Array.isArray(value) && value.length > 0) {
-            return `it composes schemas with \`${key}\`, which cannot be flattened here`;
-        }
-    }
-    const additional = node['additionalProperties'];
-    if (additional !== undefined && additional !== false) {
-        return 'it declares `additionalProperties`, so it may carry fields it does not list';
-    }
-    return null;
-}
+import { collectParameters, COMPOSITION_KEYS, deref, jsonContent, loadApiDocument, NO_PROPERTIES, parametersOf, refName, SCALAR_TYPES, schemaOf, unreadableConstruct, UNRESOLVED_REF } from './api-diff-openapi-schema-read.js';
+export { loadApiDocument };
 /**
  * Renders an OpenAPI schema as a TypeScript-ish type text. Arrays render as
  * `Array<X>` (not `X[]`) on purpose: `normalizeType` rewrites both sides
@@ -87,7 +40,9 @@ function schemaToTypeString(schema, doc, depth) {
     const enumValues = node['enum'];
     let base;
     if (Array.isArray(enumValues) && enumValues.length > 0) {
-        base = enumValues.map((value) => (typeof value === 'string' ? JSON.stringify(value) : String(value))).join(' | ');
+        base = enumValues
+            .map((value) => (typeof value === 'string' ? JSON.stringify(value) : String(value)))
+            .join(' | ');
     }
     else if (COMPOSITION_KEYS.some((key) => Array.isArray(node[key]) && node[key].length > 0)) {
         const key = COMPOSITION_KEYS.find((candidate) => Array.isArray(node[candidate]));
@@ -101,7 +56,9 @@ function schemaToTypeString(schema, doc, depth) {
         // leaked an unmapped `integer`, which this file's own comment records as a
         // source of false `number -> integer` exact lines.
         base = node['type']
-            .map((entry) => (typeof entry === 'string' && SCALAR_TYPES[entry] !== undefined ? SCALAR_TYPES[entry] : String(entry)))
+            .map((entry) => typeof entry === 'string' && SCALAR_TYPES[entry] !== undefined
+            ? SCALAR_TYPES[entry]
+            : String(entry))
             .join(' | ');
     }
     else {
@@ -122,18 +79,7 @@ function schemaToTypeString(schema, doc, depth) {
     }
     return nullable ? `${base} | null` : base;
 }
-/**
- * Flat leaf fields of a body/response schema. Arrays descend one level into
- * `items`. The ROOT `$ref` is resolved on purpose — a top-level `$ref` response
- * IS the interface — while nested refs stay named (see `schemaToTypeString`).
- *
- * A node carrying `allOf`/`oneOf`/`anyOf` or `additionalProperties` alongside its
- * own `properties` is INCOMPLETE: the sibling properties made the location look
- * non-empty, so there was neither suppression nor a note, and a field declared
- * under `allOf` was reported as an exact `-> (absent)`.
- */
-const UNRESOLVED_REF = 'its schema is a `$ref` chain deeper than the reader resolves';
-const NO_PROPERTIES = 'its schema lists no `properties`, so no field set could be read from it';
+export { schemaToTypeString };
 function collectFields(schema, doc) {
     const fields = new Map();
     const node = deref(schema, doc, 0);
@@ -179,34 +125,6 @@ function collectFields(schema, doc) {
     }
     return { fields, incompleteReason: null };
 }
-function jsonContent(content) {
-    if (!isRecord(content))
-        return undefined;
-    if (content['application/json'] !== undefined)
-        return content['application/json'];
-    return Object.values(content)[0];
-}
-function schemaOf(media) {
-    return isRecord(media) ? media['schema'] : undefined;
-}
-function collectParameters(parameters, locations) {
-    if (!Array.isArray(parameters))
-        return;
-    for (const raw of parameters) {
-        if (!isRecord(raw))
-            continue;
-        const where = raw['in'];
-        const name = raw['name'];
-        if (where !== 'path' && where !== 'query')
-            continue;
-        if (typeof name !== 'string')
-            continue;
-        const key = where === 'path' ? 'pathParams' : 'queryParams';
-        const bucket = locations.get(key) ?? new Map();
-        bucket.set(name, schemaToTypeString(raw['schema'], {}, 0));
-        locations.set(key, bucket);
-    }
-}
 export function parseOpenApiDocument(file, doc) {
     const version = doc['openapi'];
     if (typeof version !== 'string' || !/^3\.\d+/.test(version.trim())) {
@@ -234,8 +152,8 @@ export function parseOpenApiDocument(file, doc) {
                 if (read.incompleteReason !== null)
                     locationIssues.set(location, read.incompleteReason);
             };
-            const shared = Array.isArray(pathItem['parameters']) ? pathItem['parameters'] : [];
-            const own = Array.isArray(opRaw['parameters']) ? opRaw['parameters'] : [];
+            const shared = parametersOf(pathItem);
+            const own = parametersOf(opRaw);
             collectParameters([...shared, ...own], locations);
             const requestBody = opRaw['requestBody'];
             const bodySchema = schemaOf(jsonContent(isRecord(requestBody) ? requestBody['content'] : undefined));
@@ -263,34 +181,9 @@ export function parseOpenApiDocument(file, doc) {
     }
     const info = doc['info'];
     const title = isRecord(info) && typeof info['title'] === 'string' ? info['title'] : undefined;
-    return title === undefined ? { openapi: version, operations } : { openapi: version, title, operations };
-}
-/** Reads and parses `.json` / `.yaml` / `.yml`. Throws `ApiDiffInputError` on anything else. */
-export function loadApiDocument(file) {
-    let raw;
-    try {
-        raw = readFileSync(file, 'utf8');
-    }
-    catch (error) {
-        throw new ApiDiffInputError('UNREADABLE', `cannot read ${file}: ${error.message}`);
-    }
-    const lower = file.toLowerCase();
-    let parsed;
-    try {
-        if (lower.endsWith('.yaml') || lower.endsWith('.yml'))
-            parsed = parseYaml(raw);
-        else if (lower.endsWith('.json') || raw.trimStart().startsWith('{'))
-            parsed = JSON.parse(raw);
-        else
-            parsed = parseYaml(raw);
-    }
-    catch (error) {
-        throw new ApiDiffInputError('PARSE_FAILED', `cannot parse ${file} as JSON or YAML: ${error.message}`);
-    }
-    if (!isRecord(parsed)) {
-        throw new ApiDiffInputError('NOT_AN_OBJECT', `${file} did not parse to an object`);
-    }
-    return parseOpenApiDocument(file, parsed);
+    return title === undefined
+        ? { openapi: version, operations }
+        : { openapi: version, title, operations };
 }
 /** Splits on a separator that sits at bracket depth 0, leaving `("a" | "b")[]` and `Record<string, number>` intact. */
 function splitTopLevel(text, separator) {
@@ -344,7 +237,10 @@ function splitTopLevel(text, separator) {
  * `X | undefined` used to become `X | undefined | undefined`.
  */
 export function normalizeType(text) {
-    let out = text.trim().replace(/[;,]\s*$/, '').replace(/\s+/g, ' ');
+    let out = text
+        .trim()
+        .replace(/[;,]\s*$/, '')
+        .replace(/\s+/g, ' ');
     out = out.replace(/'([^'\\]*)'/g, '"$1"');
     out = out.replace(/\s*\|\s*/g, ' | ').replace(/\s*&\s*/g, ' & ');
     const union = splitTopLevel(out, ' | ');
@@ -352,7 +248,7 @@ export function normalizeType(text) {
         out = [...new Set(union)].join(' | ');
     out = out.replace(/\s*\[\s*\]/g, '[]');
     for (let pass = 0; pass < 3; pass += 1) {
-        out = out.replace(/Array<([^<>]*)>/g, (_all, inner) => (/[|&]/.test(inner) ? `(${inner})[]` : `${inner}[]`));
+        out = out.replace(/Array<([^<>]*)>/g, (_all, inner) => /[|&]/.test(inner) ? `(${inner})[]` : `${inner}[]`);
     }
     out = out.replace(/\s*<\s*/g, '<').replace(/\s*>\s*/g, '>');
     return out.trim();

package/dist/services/scan/api-diff-recorded.js

@@ -19,8 +19,19 @@ const MAX_HITS_PER_NAME = 5;
 const MAX_SCAN_FILE_BYTES = 2 * 1024 * 1024;
 const SCAN_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.vue', '.json', '.html'];
 const SKIP_DIRS = new Set([
-    'node_modules', '.git', 'dist', 'build', 'out', 'coverage', '.next', '.nuxt', '.output',
-    '.peaks', '.turbo', '.cache', '__pycache__'
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    'out',
+    'coverage',
+    '.next',
+    '.nuxt',
+    '.output',
+    '.peaks',
+    '.turbo',
+    '.cache',
+    '__pycache__'
 ]);
 // ---------------------------------------------------------------------------
 // Recorded interface extraction (NO TypeScript compiler)
@@ -218,7 +229,9 @@ function truncate(text, max = 40) {
 export function parseRecordedInterfaces(source, file) {
     const lines = stripComments(source).split(/\r?\n/);
     const fileBalanced = braceBalance(lines.join('\n')) === 0;
-    const fileReason = fileBalanced ? null : 'the file has unbalanced braces, so its structure could not be read';
+    const fileReason = fileBalanced
+        ? null
+        : 'the file has unbalanced braces, so its structure could not be read';
     const found = [];
     let i = 0;
     while (i < lines.length) {