@zxyycom/vibe-check 0.0.1 → 0.0.2

package/types/package-checks/function-metrics/analyzer/readers/swift.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/swift.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to the product-owned TypeScript analyzer.
+ */
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import type { TokenStream } from "../contracts.ts";
+import { CodeReader, type TokenFactory } from "../shared/code-reader.ts";
+/** TypeScript composition equivalent of SwiftReplaceLabel's Python mixin. */
+export declare class SwiftReplaceLabel {
+    private readonly conditions;
+    constructor(conditions: ReadonlySet<string>);
+    preprocess(tokens: TokenStream): Generator<string>;
+}
+export declare class SwiftReader extends CodeReader {
+    static readonly FUNC_KEYWORD = "def";
+    static ext: string[];
+    static languageNames: string[];
+    static controlFlowKeywords: Set<string>;
+    static logicalOperators: Set<string>;
+    static caseKeywords: Set<string>;
+    static ternaryOperators: Set<string>;
+    private readonly replaceLabel;
+    constructor(context: FileInfoBuilder);
+    static generateTokens(sourceCode: string, addition?: string, tokenFactory?: TokenFactory): Generator<string>;
+    preprocess(tokens: TokenStream): Generator<string>;
+    get_comment_from_token(token: string): string | undefined;
+}

package/types/package-checks/function-metrics/analyzer/readers/tsx.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/tsx.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to the product-owned TypeScript analyzer.
+ */
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import { TypeScriptReader } from "./typescript.ts";
+export declare class TSXReader extends TypeScriptReader {
+    static ext: string[];
+    static languageNames: string[];
+    constructor(context: FileInfoBuilder);
+    static generateTokens: import("../shared/js-style-regex.ts").TokenGenerator;
+}

package/types/package-checks/function-metrics/analyzer/readers/ttcn.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/ttcn.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to TypeScript while retaining TTCN's C-like parser,
+ * preprocessing, declaration and implementation state transitions.
+ */
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import { CLikeReader } from "../shared/clike.ts";
+import { type TokenFactory } from "../shared/code-reader.ts";
+/** TTCN-3 reader with source-derived tokenizer additions and condition categories. */
+export declare class TTCNReader extends CLikeReader {
+    static ext: readonly string[];
+    static languageNames: readonly string[];
+    static controlFlowKeywords: Set<string>;
+    static logicalOperators: Set<string>;
+    static caseKeywords: Set<string>;
+    static ternaryOperators: Set<string>;
+    constructor(context: FileInfoBuilder);
+    static generateTokens(sourceCode: string, _addition?: string, tokenFactory?: TokenFactory): Generator<string>;
+}

package/types/package-checks/function-metrics/analyzer/readers/typescript.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/typescript.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to the product-owned TypeScript analyzer.
+ */
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import { CodeReader } from "../shared/code-reader.ts";
+export declare class TypeScriptReader extends CodeReader {
+    static ext: string[];
+    static languageNames: string[];
+    static controlFlowKeywords: Set<string>;
+    static logicalOperators: Set<string>;
+    static caseKeywords: Set<string>;
+    static ternaryOperators: Set<string>;
+    constructor(context: FileInfoBuilder);
+    static generateTokens: import("../shared/js-style-regex.ts").TokenGenerator;
+    get_comment_from_token(token: string): string | undefined;
+}
+/** Source-aligned tokenizer base shared with the TSX reader. */
+export declare class Tokenizer {
+    sub_tokenizer: Tokenizer | undefined;
+    _ended: boolean;
+    constructor();
+    __call__(token: string): Generator<string>;
+    stop(): void;
+    process_token(_token: string): Generator<string>;
+}
+/** Source-aligned JavaScript brace tokenizer used by TSX embedded expressions. */
+export declare class JSTokenizer extends Tokenizer {
+    private depth;
+    constructor();
+    process_token(token: string): Generator<string>;
+}

package/types/package-checks/function-metrics/analyzer/readers/vue.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/vue.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to the product-owned TypeScript analyzer.
+ */
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import type { TokenStream } from "../contracts.ts";
+import { type TokenFactory } from "../shared/code-reader.ts";
+import { TypeScriptReader } from "./typescript.ts";
+export declare class VueReader extends TypeScriptReader {
+    static ext: string[];
+    static languageNames: string[];
+    constructor(context: FileInfoBuilder);
+    static generateTokens(sourceCode: string, addition?: string, tokenFactory?: TokenFactory): Generator<string>;
+    preprocess(tokens: TokenStream): Generator<string>;
+}

package/types/package-checks/function-metrics/analyzer/readers/zig.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/zig.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to the product-owned TypeScript analyzer.
+ */
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import { CodeReader } from "../shared/code-reader.ts";
+export declare class ZigReader extends CodeReader {
+    static ext: string[];
+    static languageNames: string[];
+    static controlFlowKeywords: Set<string>;
+    static logicalOperators: Set<string>;
+    static caseKeywords: Set<string>;
+    static ternaryOperators: Set<string>;
+    constructor(context: FileInfoBuilder);
+    get_comment_from_token(token: string): string | undefined;
+}

package/types/package-checks/function-metrics/analyzer/shared/clike.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/clike.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to TypeScript with the upstream state ordering and
+ * intermediate reader context preserved.
+ */
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import type { TokenStream } from "../contracts.ts";
+import { CodeReader, CodeStateMachine, type TokenFactory } from "./code-reader.ts";
+/** Source-aligned C/C++ comment extraction shared by C-like readers. */
+export declare class CCppCommentsMixin {
+    static get_comment_from_token(token: string): string | undefined;
+    /** TS-facing call sites share the source method's one implementation. */
+    static getCommentFromToken(token: string): string | undefined;
+}
+/** Base reader for C, C++, and Java-like source structures. */
+export declare class CLikeReader extends CodeReader {
+    static ext: readonly string[];
+    static languageNames: readonly string[];
+    private static readonly macro_pattern;
+    constructor(context: FileInfoBuilder);
+    static generateTokens(sourceCode: string, addition?: string, tokenFactory?: TokenFactory): Generator<string>;
+    get_comment_from_token(token: string): string | undefined;
+    preprocess(tokens: TokenStream): Generator<string>;
+}
+/** Tracks C-like namespace/class and brace nesting independently of functions. */
+export declare class CLikeNestingStackStates extends CodeStateMachine {
+    private static readonly __namespace_separators;
+    statemachine_clone(): CLikeNestingStackStates;
+    _state_global(token: string): void;
+    private readonly _dot;
+    private readonly _read_namespace;
+    private readonly _read_namespace_name;
+    private readonly finishNamespaceName;
+    private readonly _template_declaration;
+    private readonly _read_attribute;
+    private readonly ignoreToken;
+}
+/**
+ * Finds C-like declarations, parameters, and implementations.
+ *
+ * The following virtual methods are intentionally retained as unbound state
+ * slots. `CodeStateMachine` invokes its stored state as `this.state(token)`,
+ * which restores this instance as the receiver; preserving the method identity
+ * is required for source-derived subclass override and state comparisons.
+ */
+export declare class CLikeStates extends CodeStateMachine {
+    /** Source class attribute `parameter_bracket_open`; TTCN overrides it. */
+    protected static readonly parameter_bracket_open: ReadonlySet<string>;
+    /** Source class attribute `parameter_bracket_close`; TTCN overrides it. */
+    protected static readonly parameter_bracket_close: ReadonlySet<string>;
+    private readonly bracket_stack;
+    private _saved_tokens;
+    constructor(context: FileInfoBuilder);
+    statemachine_clone(): CLikeStates;
+    protected get parameter_bracket_open(): ReadonlySet<string>;
+    protected get parameter_bracket_close(): ReadonlySet<string>;
+    try_new_function(name: string): void;
+    _state_global(token: string): void;
+    protected readonly _state_function: (token: string) => void;
+    private readonly _state_template_in_name;
+    private readonly addTemplateToken;
+    private readonly _state_operator;
+    private readonly _state_operator_next;
+    private readonly _state_name_with_space;
+    /** Source override seam: _state_dec. */
+    protected _state_dec(token: string): void;
+    private readonly readDeclarationToken;
+    /** Source override seam: _state_dec_to_imp. */
+    protected _state_dec_to_imp(token: string): void;
+    private readonly _state_throw;
+    private readonly finishThrow;
+    private readonly _state_throws;
+    private readonly finishThrows;
+    private readonly _state_noexcept;
+    private readonly _state_trailing_return;
+    private readonly finishTrailingReturn;
+    /** Source override seam: _state_old_c_params. */
+    protected _state_old_c_params(token: string): void;
+    private readonly _state_initialization_list;
+    private readonly _state_one_initialization;
+    private readonly finishOneInitialization;
+    private readonly _state_initialization_value1;
+    private readonly _state_initialization_value2;
+    private readonly finishInitializationValue;
+    /** Source override seam: _state_entering_imp. */
+    protected _state_entering_imp(token: string): void;
+    /** Source override seam: _state_imp. */
+    protected _state_imp(token: string): void;
+    private readonly finishImplementation;
+    private readonly _state_attribute;
+    private readonly _state_lambda_check;
+    private readonly _state_lambda_params;
+    private readonly _state_lambda_param_list;
+    private readonly _state_lambda_body;
+    private readonly _state_lambda_body_skip;
+    private readonly _state_lambda_capture;
+    private readonly ignoreToken;
+}

package/types/package-checks/function-metrics/analyzer/shared/code-reader.d.ts

@@ -0,0 +1,176 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/code_reader.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to TypeScript while retaining the tokenizer and
+ * state-machine sequencing used by concrete Lizard language readers.
+ */
+import type { AnalyzerReader, TokenStream } from "../contracts.ts";
+import type { FileInfoBuilder } from "../analysis-context.ts";
+/** A regex match passed to language-specific token factories. */
+export declare class TokenMatch {
+    readonly text: string;
+    readonly startOffset: number;
+    constructor(text: string, startOffset: number);
+    /** Python's re.Match.group(0), retained for direct reader translations. */
+    group(index?: number): string | undefined;
+    /** Python's re.Match.start(), retained for direct reader translations. */
+    start(): number;
+}
+/** Converts one tokenizer match into the token stream representation. */
+export type TokenFactory = (match: TokenMatch) => string;
+export type StateHandler = (this: CodeStateMachine, token: string) => boolean | void;
+export type UntilStateHandler = (this: CodeStateMachine, token: string, savedTokens: readonly string[]) => boolean | void;
+export type State = CodeStateMachine | StateHandler;
+export type SourceStateHandler = (state: CodeStateMachine, token: string) => boolean | void;
+export type SourceUntilStateHandler = (state: CodeStateMachine, token: string, savedTokens: string[]) => boolean | void;
+export interface ReaderDefinition {
+    readonly controlFlowKeywords: ReadonlySet<string>;
+    readonly logicalOperators: ReadonlySet<string>;
+    readonly caseKeywords: ReadonlySet<string>;
+    readonly ternaryOperators: ReadonlySet<string>;
+    buildConditions(): Set<string>;
+}
+/** Python str.isspace(), including its four extra C0 information separators. */
+export declare function isPythonWhitespace(value: string): boolean;
+/** Python str.splitlines() without retaining source line-boundary characters. */
+export declare function splitPythonLines(value: string): string[];
+/**
+ * The small state-machine foundation used by source-aligned language readers.
+ * It deliberately preserves upstream's one saved sub-state and callback slot.
+ */
+export declare class CodeStateMachine {
+    context: FileInfoBuilder;
+    lastToken: string | undefined;
+    protected state: State;
+    protected savedState: State;
+    protected toExit: boolean;
+    callback: (() => void) | undefined;
+    protected readUntilTokens: string[];
+    protected bracketCount: number;
+    protected readonly stateMachineConstructor: typeof CodeStateMachine;
+    protected readonly globalState: StateHandler;
+    constructor(context: FileInfoBuilder);
+    /** Source field aliases retain one state slot for translated state machines. */
+    get saved_state(): State;
+    set saved_state(value: State);
+    get _state(): State;
+    set _state(value: State);
+    get last_token(): string | undefined;
+    set last_token(value: string | undefined);
+    get to_exit(): boolean;
+    set to_exit(value: boolean);
+    get rut_tokens(): string[];
+    set rut_tokens(value: string[]);
+    get br_count(): number;
+    set br_count(value: number);
+    /** TS-facing alias for the source clone hook. */
+    cloneState(): CodeStateMachine;
+    /** Equivalent to Python's statemachine_clone. */
+    statemachine_clone(): CodeStateMachine;
+    next(state: State, token?: string): boolean | void;
+    nextIf(state: State, token: string, expected: string): boolean | void;
+    next_if(state: State, token: string, expected: string): boolean | void;
+    returnFromState(): void;
+    statemachine_return(): void;
+    subState(state: State, callback?: () => void, token?: string): boolean | void;
+    sub_state(state: State, callback?: () => void, token?: string): boolean | void;
+    /** Feed one token through the current state. */
+    consume(token: string): boolean;
+    /** Invoke only the current state; ExtensionBase retains this upstream seam. */
+    protected invokeCurrentState(token: string): boolean;
+    /** TS-facing state hook used by existing translated reader subclasses. */
+    protected stateGlobal(_token: string): void;
+    /** Source readers/extensions may retain this source-spelled state hook. */
+    _state_global(token: string): void;
+    /** Source readers/extensions may retain this source-spelled return hook. */
+    statemachine_before_return(): void;
+    /** TS-facing alias for the source pre-return hook. */
+    beforeReturn(): void;
+    /** Source decorator factory retained for translated reader/extension state methods. */
+    static read_inside_brackets_then(brackets: string, endState?: string): (action: SourceStateHandler) => StateHandler;
+    /** Source decorator factory retained for translated reader/extension state methods. */
+    static read_until_then(tokens: string): (action: SourceUntilStateHandler) => StateHandler;
+    /**
+     * Source-aligned replacement for read_inside_brackets_then.  Call from a
+     * reader state for the token currently being consumed.
+     */
+    protected readInsideBracketsThen(brackets: string, token: string, action: StateHandler, endState?: State): void;
+    /** Source-aligned replacement for read_until_then. */
+    protected readUntilThen(stopTokens: string, token: string, action: UntilStateHandler): void;
+}
+/** Base tokenizer and state fan-out used by all translated concrete readers. */
+export declare class CodeReader implements AnalyzerReader {
+    static ext: readonly string[];
+    static languages: unknown;
+    static languageNames: readonly string[];
+    /** Source `language_names` shares storage with the TS-facing class field. */
+    static get language_names(): readonly string[];
+    static set language_names(value: readonly string[]);
+    static extraSubclasses: Set<typeof CodeReader>;
+    /** Source `extra_subclasses` shares storage with the TS-facing class field. */
+    static get extra_subclasses(): Set<typeof CodeReader>;
+    static set extra_subclasses(value: Set<typeof CodeReader>);
+    static controlFlowKeywords: ReadonlySet<string>;
+    static logicalOperators: ReadonlySet<string>;
+    static caseKeywords: ReadonlySet<string>;
+    static ternaryOperators: ReadonlySet<string>;
+    /** Source class-level condition categories retain their source spellings. */
+    static get _control_flow_keywords(): ReadonlySet<string>;
+    static set _control_flow_keywords(value: ReadonlySet<string>);
+    static get _logical_operators(): ReadonlySet<string>;
+    static set _logical_operators(value: ReadonlySet<string>);
+    static get _case_keywords(): ReadonlySet<string>;
+    static set _case_keywords(value: ReadonlySet<string>);
+    static get _ternary_operators(): ReadonlySet<string>;
+    static set _ternary_operators(value: ReadonlySet<string>);
+    conditions: Set<string>;
+    controlFlowKeywords: Set<string>;
+    logicalOperators: Set<string>;
+    caseKeywords: Set<string>;
+    ternaryOperators: Set<string>;
+    parallelStates: CodeStateMachine[];
+    context: FileInfoBuilder;
+    private readonly readerClass;
+    constructor(context: FileInfoBuilder, readerDefinition?: ReaderDefinition);
+    /** Source `parallel_states` shares the mutable per-reader state list. */
+    get parallel_states(): CodeStateMachine[];
+    set parallel_states(value: CodeStateMachine[]);
+    /** Python class attributes are visible through each reader instance. */
+    get languages(): unknown;
+    get extraSubclasses(): Set<typeof CodeReader>;
+    get extra_subclasses(): Set<typeof CodeReader>;
+    get control_flow_keywords(): Set<string>;
+    set control_flow_keywords(value: Set<string>);
+    get logical_operators(): Set<string>;
+    set logical_operators(value: Set<string>);
+    get case_keywords(): Set<string>;
+    set case_keywords(value: Set<string>);
+    get ternary_operators(): Set<string>;
+    set ternary_operators(value: Set<string>);
+    /** Python exposes the concrete class's ext through each reader instance. */
+    get ext(): readonly string[];
+    /** Python exposes the concrete class's language_names through each reader instance. */
+    get languageNames(): readonly string[];
+    /** Source `language_names` instance accessor, aliased to `languageNames`. */
+    get language_names(): readonly string[];
+    static buildConditions(this: typeof CodeReader): Set<string>;
+    static _build_conditions(this: typeof CodeReader): Set<string>;
+    static matchFilename(this: typeof CodeReader, filename: string): boolean;
+    static match_filename(this: typeof CodeReader, filename: string): boolean;
+    /** The shared source-aligned tokenizer used by all language readers. */
+    static generateTokens(sourceCode: string, addition?: string, tokenFactory?: TokenFactory): Generator<string>;
+    static generate_tokens(sourceCode: string, addition?: string, tokenFactory?: TokenFactory): TokenStream;
+    /** Source `CodeReader.__call__` updates context before draining the reader pipeline. */
+    __call__(tokens: TokenStream, reader: AnalyzerReader): TokenStream;
+    process(tokens: TokenStream): Generator<string>;
+    get_comment_from_token(_token: string): string | undefined;
+    /** TS-facing analyzer interface alias for the source reader hook. */
+    getCommentFromToken(token: string): string | undefined;
+    eof(): void;
+    /** Return true only when a reader intentionally bypasses normal state work. */
+    process_token(_token: string): boolean;
+    /** TS-facing alias retained for the AnalyzerReader host interface. */
+    processToken(token: string): boolean;
+}

package/types/package-checks/function-metrics/analyzer/shared/golike.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/golike.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to TypeScript while retaining Go-like function and
+ * nested-block state transitions.
+ */
+import { CodeStateMachine } from "./code-reader.ts";
+/**
+ * Shared state machine for Go-like readers.
+ *
+ * Function transition methods deliberately remain prototype methods: source
+ * subclasses use `super` and the state machine invokes stored methods with its
+ * owning receiver. This preserves both override dispatch and state identity.
+ */
+export declare class GoLikeStates extends CodeStateMachine {
+    protected static readonly FUNC_KEYWORD: string;
+    private _type_param_open;
+    private _type_param_close;
+    _state_global(token: string): void;
+    protected readonly _type_definition: (_token: string) => void;
+    private readonly _after_type_name;
+    private readonly _struct_definition;
+    private readonly _interface_definition;
+    /** Source `_function_name` virtual seam used by Kotlin. */
+    protected _function_name(token: string): void;
+    private readonly _expect_function_dec;
+    private readonly _skip_type_parameters;
+    private readonly _member_function;
+    private readonly addMemberFunctionToken;
+    private readonly _function_dec;
+    private readonly addFunctionParameter;
+    /** Source `_expect_function_impl` virtual seam used by Scala and Kotlin. */
+    protected _expect_function_impl(token: string): void;
+    protected readonly _function_impl: (_token: string) => void;
+    private readonly ignoreToken;
+    private getFunctionKeyword;
+}

package/types/package-checks/function-metrics/analyzer/shared/js-style-regex.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/js_style_regex_expression.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to a TypeScript tokenizer wrapper while preserving the
+ * upstream eager regex-token combination order.
+ */
+import type { TokenFactory } from "./code-reader.ts";
+/** A static reader tokenizer shape accepted by the JavaScript regex wrapper. */
+export type TokenGenerator = (sourceCode: string, addition?: string, tokenFactory?: TokenFactory) => Generator<string>;
+/**
+ * Wrap a tokenizer with Lizard's JavaScript-style regular-expression joining.
+ * The final index advance intentionally mirrors the upstream implementation.
+ */
+export declare function js_style_regex_expression(generator: TokenGenerator): TokenGenerator;

package/types/package-checks/function-metrics/analyzer/shared/rubylike.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/rubylike.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to TypeScript with source-aligned nested-state and
+ * callback sequencing for Ruby-like readers.
+ */
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import { CodeReader, CodeStateMachine } from "./code-reader.ts";
+/** The embedded-document substate from the upstream module. */
+export declare function state_embedded_doc(token: string): boolean;
+/** Shared function/block state machine for Ruby-like languages. */
+export declare class RubylikeStateMachine extends CodeStateMachine {
+    protected static readonly FUNC_KEYWORD: string;
+    constructor(context: FileInfoBuilder);
+    _state_global(token: string): void;
+    is_newline(): boolean;
+    private getFunctionKeyword;
+    /** Source `_def` seam used by Lua's `_anonymous_def` transition. */
+    protected readonly _def: (token: string) => void;
+    private readonly _it;
+    /** Source `_def_continue` seam used by Lua _defs. */
+    protected readonly _def_continue: (token: string) => void;
+    /** Source `_def_class_method` seam used by Lua _defs. */
+    protected readonly _def_class_method: (token: string) => void;
+    /** Source `_def_parameters` seam used by Lua's `_anonymous_def` transition. */
+    protected readonly _def_parameters: (token: string) => void;
+    private readonly _if;
+    private readonly _for_while;
+}
+/** Shared reader configuration for Ruby-like languages. */
+export declare class RubylikeReader extends CodeReader {
+    static controlFlowKeywords: ReadonlySet<string>;
+    static logicalOperators: ReadonlySet<string>;
+    static caseKeywords: ReadonlySet<string>;
+    static ternaryOperators: ReadonlySet<string>;
+    constructor(context: FileInfoBuilder);
+    get_comment_from_token(token: string): string | undefined;
+}

package/types/package-checks/function-metrics/analyzer/shared/script-language.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/script_language.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to TypeScript while retaining the source mixin's
+ * static comment and tokenizer members.
+ */
+import { type TokenFactory } from "./code-reader.ts";
+/** Common comment extraction and tokenization used by script-language readers. */
+export declare class ScriptLanguageMixIn {
+    static get_comment_from_token(token: string): string | undefined;
+    static generate_common_tokens(sourceCode: string, addition: string, tokenFactory?: TokenFactory): Generator<string>;
+    /** TS-facing call sites share the source methods' implementations. */
+    static getCommentFromToken(token: string): string | undefined;
+    static generateCommonTokens(sourceCode: string, addition: string, tokenFactory?: TokenFactory): Generator<string>;
+}

package/types/package-checks/function-metrics/analyzer-adapter.d.ts

@@ -0,0 +1,26 @@
+import type { FunctionMetric } from "./measurement-model.ts";
+/** One parent-admitted source passed through the Product adapter to the Lizard port. */
+export interface FunctionMetricsAnalyzerSource {
+    readonly path: string;
+    readonly source: string;
+}
+/** The complete in-memory source batch that one Worker asks the adapter to analyze. */
+export interface FunctionMetricsAnalyzerInput {
+    readonly files: readonly FunctionMetricsAnalyzerSource[];
+}
+/** Product-facing result of a complete adapter analysis; failures never carry a prefix. */
+export type FunctionMetricsAnalyzerResult = Readonly<{
+    readonly kind: "analysis-failed";
+}> | Readonly<{
+    readonly kind: "complete";
+    readonly metrics: readonly FunctionMetric[];
+}>;
+/** The translated port's fixed suffix capability, presented for functionMetrics selection. */
+export declare const FUNCTION_METRICS_SUPPORTED_FILE_EXTENSIONS: readonly string[];
+/** Whether a Product-selected path is supported by the translated Lizard port. */
+export declare function isFunctionMetricsAnalyzerSourceSupported(filePath: string): boolean;
+/**
+ * Maps complete Lizard-domain analyses into the Product's function metrics.
+ * An unsupported source or analyzer exception discards every collected metric.
+ */
+export declare function analyzeFunctionMetricsSources(input: FunctionMetricsAnalyzerInput): FunctionMetricsAnalyzerResult;

package/types/package-checks/function-metrics/analyzer-worker-contract.d.ts

@@ -0,0 +1,5 @@
+import type { FunctionMetricsAnalyzerInput, FunctionMetricsAnalyzerResult } from "./analyzer-adapter.ts";
+/** Exact, already-admitted source texts passed from one functionMetrics Check to its Worker. */
+export type FunctionMetricsAnalysisWorkerRequest = FunctionMetricsAnalyzerInput;
+/** The one-shot Worker response; errors never carry partial measurements. */
+export type FunctionMetricsAnalysisWorkerResponse = FunctionMetricsAnalyzerResult;

package/types/package-checks/function-metrics/analyzer-worker-port.d.ts

@@ -0,0 +1,24 @@
+import type { FunctionMetricsAnalysisWorkerRequest } from "./analyzer-worker-contract.ts";
+import type { FunctionMetric } from "./measurement-model.ts";
+type FunctionMetricsWorkerAnalysisResult = Readonly<{
+    kind: "analysis-failed";
+} | {
+    kind: "cancelled";
+} | {
+    kind: "complete";
+    metrics: readonly FunctionMetric[];
+}>;
+export interface FunctionMetricsWorkerPort {
+    readonly postMessage: (value: unknown) => void;
+    readonly subscribe: (listeners: Readonly<{
+        readonly error: () => void;
+        readonly exit: (code: number) => void;
+        readonly message: (value: unknown) => void;
+    }>) => () => void;
+    readonly terminate: () => void;
+}
+/** Creates the private Node Worker transport for one admitted analyzer batch. */
+export declare function createNodeFunctionMetricsWorker(): FunctionMetricsWorkerPort;
+/** Runs one admitted batch through a Worker and settles its transport exactly once. */
+export declare function analyzeAdmittedSources(request: FunctionMetricsAnalysisWorkerRequest, approvedExactPaths: readonly string[], signal: AbortSignal, createWorker: () => FunctionMetricsWorkerPort): Promise<FunctionMetricsWorkerAnalysisResult>;
+export {};

package/types/package-checks/function-metrics/analyzer-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/types/package-checks/function-metrics/constructor.d.ts

@@ -6,6 +6,6 @@ import type { FunctionMetricsOptions, ResolvedFunctionMetricsOptions } from "./o
  *
  * @param options - 省略字段由 package 补齐；显式 files 数组完整替换对应字段的默认数组。
  * @returns 固定 `function-metrics` identity、完整冻结 options、preflight 与 execution。
- * @throws {TypeError} input 含未知字段、空 area、非法 finding policy、非法 limit 或空 executable 时抛出。
+ * @throws {TypeError} input 含未知字段、空 area、非法 finding policy/waiver 或非法 limit 时抛出。
  */
 export declare function functionMetrics(options?: FunctionMetricsOptions): TypedCheckWithOptions<"function-metrics", ResolvedFunctionMetricsOptions, typeof parseFunctionMetricsData>;

package/types/package-checks/function-metrics/execution.d.ts

@@ -1,7 +1,10 @@
 import type { CheckExecutionContext, CheckResult } from "../../check/check.ts";
+import { type FunctionMeasurementDependencies } from "./measurement.ts";
 import type { ResolvedFunctionMetricsOptions } from "./options.ts";
 import type { FunctionMetricsFinalData } from "./final-data.ts";
 /** `function-metrics` whole-Check unavailable outcome 的稳定 reason code。 */
-export type FunctionMetricsUnavailableReasonCode = "cancelled" | "external-dependency-unavailable" | "external-execution-failed" | "external-result-invalid" | "invalid-options" | "source-unavailable";
+export type FunctionMetricsUnavailableReasonCode = "analysis-failed" | "cancelled" | "invalid-options" | "resource-limit-exceeded" | "source-unavailable";
 /** Default Check callback；一次扫描完整 area exact-input union。 */
-export declare function executeFunctionMetrics(context: CheckExecutionContext<ResolvedFunctionMetricsOptions>): Promise<CheckResult<FunctionMetricsFinalData>>;
+export declare function executeFunctionMetrics(context: CheckExecutionContext<ResolvedFunctionMetricsOptions>, dependencies?: Readonly<{
+    readonly measurement?: Partial<FunctionMeasurementDependencies>;
+}>): Promise<CheckResult<FunctionMetricsFinalData>>;

package/types/package-checks/function-metrics/finding-messages.d.ts

@@ -0,0 +1,9 @@
+import type { CheckMessage } from "../../check/check.ts";
+import type { FindingWaiverReconciliation } from "../../finding-waivers/reconciliation.ts";
+import { type FunctionInputRejectedCandidate, type FunctionRecordCandidate } from "./records.ts";
+type FunctionFindingCandidate = FunctionRecordCandidate | FunctionInputRejectedCandidate;
+/** Projects metric and rejected-input Records into bounded terminal summaries. */
+export declare function functionFindingMessages(findings: readonly FunctionFindingCandidate[]): readonly CheckMessage[];
+/** 将每项 function-metrics waiver audit 投影为可行动的 terminal message。 */
+export declare function functionWaiverMessages(reconciliation: FindingWaiverReconciliation<FunctionRecordCandidate>): readonly CheckMessage[];
+export {};

package/types/package-checks/function-metrics/finding-waiver-identity.d.ts

@@ -0,0 +1,2 @@
+import type { FunctionMetricsFindingIdentity } from "./options.ts";
+export declare function resolveFunctionMetricsFindingIdentity(value: unknown): FunctionMetricsFindingIdentity | undefined;