@wrtnlabs/evidence 0.0.0

package/lib/adapters/matlab/MatlabOwnership.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatlabOwnership = void 0;
+const node_path_1 = require("node:path");
+/**
+ * Reconciles selected class folders, external implementations, and property accessors.
+ *
+ * MATLAB distributes one public class surface across files, so semantic ownership
+ * must be proven from class-folder paths before units and annotation hosts exist.
+ */
+var MatlabOwnership;
+(function (MatlabOwnership) {
+    /**
+     * Resolves all ownership before any public identities or hosts are published.
+     *
+     * This order lets a missing external implementation remain an observable
+     * dependency and prevents an accessor from becoming a second property unit.
+     */
+    function resolve(analyses, inventory) {
+        const files = new Map(analyses.map((analysis) => [
+            analysis.source.physicalPath.replaceAll("\\", "/"),
+            analysis,
+        ]));
+        for (const analysis of analyses) {
+            const directory = node_path_1.posix.dirname(analysis.source.physicalPath.replaceAll("\\", "/"));
+            if (node_path_1.posix.basename(directory).startsWith("@"))
+                inventory.dependencies.push({ path: directory, recursive: true });
+            for (const declaration of analysis.declarations) {
+                if (declaration.externalOwner === undefined)
+                    continue;
+                inventory.dependencies.push({
+                    path: declaration.externalOwner,
+                    recursive: false,
+                });
+                const ownerAnalysis = files.get(declaration.externalOwner);
+                const owner = ownerAnalysis === undefined
+                    ? undefined
+                    : ownerAnalysis.declarations.find((candidate) => candidate.symbol === "type" &&
+                        candidate.ownerDeclarationId === undefined);
+                if (owner === undefined || ownerAnalysis === undefined) {
+                    problem(analysis, declaration, "class-folder", "An external method requires its selected @Class/Class.m classdef; legacy classes are not inferred.");
+                    declaration.public = false;
+                    continue;
+                }
+                const prototype = ownerAnalysis.declarations.find((candidate) => candidate.ownerDeclarationId === owner.id &&
+                    candidate.name === declaration.name &&
+                    candidate.symbol === "function");
+                if (prototype !== undefined && prototype.implementation === undefined)
+                    problem(analysis, declaration, "method-conflict", "An external method duplicates an inline or abstract class method.");
+                declaration.ownerDeclarationId = owner.id;
+                declaration.anchor = owner.anchor;
+                declaration.address = [...owner.address, declaration.name];
+                declaration.identity = declaration.address;
+                declaration.public &&= owner.public && (prototype?.public ?? true);
+                declaration.publicFiles = ownerAnalysis.source.addresses.map((address) => address.absolute);
+                inventory.dependencies.push({
+                    path: node_path_1.posix.dirname(declaration.externalOwner),
+                    recursive: true,
+                });
+            }
+            for (const declaration of analysis.declarations) {
+                if (declaration.implementation === undefined)
+                    continue;
+                inventory.dependencies.push({
+                    path: declaration.implementation,
+                    recursive: false,
+                });
+                const externalAnalysis = files.get(declaration.implementation);
+                const external = externalAnalysis === undefined
+                    ? undefined
+                    : externalAnalysis.declarations.find((candidate) => candidate.externalOwner === declaration.anchor &&
+                        candidate.name === declaration.name);
+                if (external === undefined)
+                    problem(analysis, declaration, "external-method", "A nonabstract external method prototype has no selected implementation; include its @Class method file.");
+            }
+        }
+        for (const analysis of analyses)
+            for (const declaration of analysis.declarations) {
+                if (declaration.accessor === undefined)
+                    continue;
+                const property = analyses
+                    .flatMap((item) => item.declarations)
+                    .find((candidate) => candidate.accessor === undefined &&
+                    candidate.getPublic !== undefined &&
+                    candidate.anchor === declaration.anchor &&
+                    candidate.ownerDeclarationId === declaration.ownerDeclarationId &&
+                    candidate.name === declaration.name);
+                if (property === undefined) {
+                    problem(analysis, declaration, "accessor", "A property accessor has no declared property in its selected class.");
+                    declaration.public = false;
+                }
+                else {
+                    declaration.public =
+                        property.public &&
+                            (declaration.accessor === "get"
+                                ? property.getPublic === true
+                                : property.setPublic === true);
+                }
+            }
+        const seen = new Map();
+        for (const analysis of analyses)
+            for (const declaration of analysis.declarations) {
+                if (!declaration.public)
+                    continue;
+                const identity = JSON.stringify([
+                    declaration.anchor,
+                    declaration.symbol,
+                    declaration.identity,
+                    declaration.accessor ??
+                        (declaration.implementation === undefined
+                            ? "definition"
+                            : "prototype"),
+                ]);
+                if (seen.has(identity))
+                    problem(analysis, declaration, "declaration-conflict", "Two declarations expose the same MATLAB owner and name.");
+                seen.set(identity, declaration);
+            }
+    }
+    MatlabOwnership.resolve = resolve;
+    /**
+     * Records unresolved source ownership without shrinking a passing population.
+     *
+     * The ownership pass retains this diagnostic when class-folder or external
+     * declarations cannot be paired, preserving an incomplete result for recovery.
+     */
+    function problem(analysis, declaration, code, message) {
+        analysis.complete = false;
+        analysis.diagnostics.push({
+            code: `matlab-${code}`,
+            severity: "error",
+            message,
+            repair: "Select a unique classdef and its external implementations, or correct the conflicting declaration.",
+            location: {
+                file: analysis.source.physicalPath,
+                range: declaration.site.range,
+            },
+        });
+    }
+})(MatlabOwnership || (exports.MatlabOwnership = MatlabOwnership = {}));

package/lib/adapters/mysql/EvidenceMysqlAdapter.d.ts

@@ -0,0 +1,16 @@
+import { SqlAdapter } from "../sql/SqlAdapter";
+/**
+ * Extracts explicitly configured MySQL schema declarations with static ownership.
+ *
+ * MysqlFileScanner supplies MySQL identifier, table, and member records to the
+ * common SQL materializer. Schema meaning comes from selected source statements;
+ * the adapter neither connects to a server nor executes migrations.
+ */
+export declare class EvidenceMysqlAdapter extends SqlAdapter {
+    /**
+     * Selects MySQL scanning within the shared parser and inventory lifecycle.
+     *
+     * Construction is inert; analyze later owns the parser runtime for its snapshot.
+     */
+    constructor();
+}

package/lib/adapters/mysql/EvidenceMysqlAdapter.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceMysqlAdapter = void 0;
+const MysqlFileScanner_1 = require("./MysqlFileScanner");
+const SqlAdapter_1 = require("../sql/SqlAdapter");
+/**
+ * Extracts explicitly configured MySQL schema declarations with static ownership.
+ *
+ * MysqlFileScanner supplies MySQL identifier, table, and member records to the
+ * common SQL materializer. Schema meaning comes from selected source statements;
+ * the adapter neither connects to a server nor executes migrations.
+ */
+class EvidenceMysqlAdapter extends SqlAdapter_1.SqlAdapter {
+    /**
+     * Selects MySQL scanning within the shared parser and inventory lifecycle.
+     *
+     * Construction is inert; analyze later owns the parser runtime for its snapshot.
+     */
+    constructor() {
+        super({ type: "mysql", scan: MysqlFileScanner_1.MysqlFileScanner.scan });
+    }
+}
+exports.EvidenceMysqlAdapter = EvidenceMysqlAdapter;

package/lib/adapters/mysql/MysqlDocumentation.d.ts

@@ -0,0 +1,15 @@
+import type { IEvidenceDocumentation } from "../../structures/IEvidenceDocumentation";
+import type { IEvidenceSourceRange } from "../../structures/IEvidenceSourceRange";
+/**
+ * Maps an attached MySQL COMMENT literal without losing original UTF-16 positions.
+ *
+ * The MySQL scanner supplies the literal range after it has established ownership.
+ */
+export declare namespace MysqlDocumentation {
+    /**
+     * Decodes SQL doubled quotes while rejecting server-mode-dependent backslash escapes.
+     *
+     * Rejection avoids assigning annotation offsets under an unknown MySQL session mode.
+     */
+    function read(content: string, range: IEvidenceSourceRange, hostId: string): IEvidenceDocumentation | undefined;
+}

package/lib/adapters/mysql/MysqlDocumentation.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlDocumentation = void 0;
+/**
+ * Maps an attached MySQL COMMENT literal without losing original UTF-16 positions.
+ *
+ * The MySQL scanner supplies the literal range after it has established ownership.
+ */
+var MysqlDocumentation;
+(function (MysqlDocumentation) {
+    /**
+     * Decodes SQL doubled quotes while rejecting server-mode-dependent backslash escapes.
+     *
+     * Rejection avoids assigning annotation offsets under an unknown MySQL session mode.
+     */
+    function read(content, range, hostId) {
+        const raw = content.slice(range.start.offset, range.end.offset);
+        if (!/^'(?:[^'\\]|'')*'$/su.test(raw))
+            return undefined;
+        const result = {
+            hostId,
+            text: "",
+            offsets: [],
+            ends: [],
+            tagBoundaries: true,
+            allowWithdrawal: true,
+        };
+        for (let cursor = range.start.offset + 1; cursor < range.end.offset - 1; ++cursor) {
+            const character = content[cursor] ?? "";
+            result.text += character;
+            result.offsets.push(cursor);
+            if (character === "'" && content[cursor + 1] === "'")
+                ++cursor;
+            result.ends.push(cursor + 1);
+        }
+        result.offsets.push(range.end.offset - 1);
+        return result;
+    }
+    MysqlDocumentation.read = read;
+})(MysqlDocumentation || (exports.MysqlDocumentation = MysqlDocumentation = {}));

package/lib/adapters/mysql/MysqlFileScanner.d.ts

@@ -0,0 +1,16 @@
+import type { ISqlFileAnalysis } from "../sql/ISqlFileAnalysis";
+import type { EvidenceParseSession } from "../../parsers/EvidenceParseSession";
+import type { IEvidenceSourceFile } from "../../structures/IEvidenceSourceFile";
+/**
+ * Enriches shared SQL extraction with MySQL COMMENT hosts and dialect policy.
+ *
+ * This namespace supplies the scanner callback used by the MySQL adapter.
+ */
+export declare namespace MysqlFileScanner {
+    /**
+     * Attaches only table and column COMMENT strings to their exact declaration owner.
+     *
+     * Shared SQL scanning supplies declarations; this pass adds dialect-specific documentation.
+     */
+    function scan(session: EvidenceParseSession, source: IEvidenceSourceFile): ISqlFileAnalysis;
+}

package/lib/adapters/mysql/MysqlFileScanner.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlFileScanner = void 0;
+const MysqlDocumentation_1 = require("./MysqlDocumentation");
+const MysqlPolicy_1 = require("./MysqlPolicy");
+const SqlFileScanner_1 = require("../sql/SqlFileScanner");
+const SourceText_1 = require("../../internal/SourceText");
+/**
+ * Enriches shared SQL extraction with MySQL COMMENT hosts and dialect policy.
+ *
+ * This namespace supplies the scanner callback used by the MySQL adapter.
+ */
+var MysqlFileScanner;
+(function (MysqlFileScanner) {
+    /**
+     * Attaches only table and column COMMENT strings to their exact declaration owner.
+     *
+     * Shared SQL scanning supplies declarations; this pass adds dialect-specific documentation.
+     */
+    function scan(session, source) {
+        const analysis = new SqlFileScanner_1.SqlFileScanner(session, source, MysqlPolicy_1.MysqlPolicy).scan();
+        const text = new SourceText_1.SourceText(source.content);
+        for (const node of descendants(session.root)) {
+            if (node.type !== "column_definition" && node.type !== "create_table")
+                continue;
+            const owner = analysis.declarations.find((declaration) => declaration.site.range.start.offset === node.startIndex);
+            if (owner === undefined)
+                continue;
+            const ranges = node.type === "column_definition"
+                ? node.namedChildren
+                    .filter((child) => child.type !== "comment" && child.type !== "marginalia")
+                    .filter((child, index, children) => child.type === "literal" &&
+                    children[index - 1]?.type === "keyword_comment")
+                    .map((literal) => session.range(literal))
+                : node.namedChildren
+                    .filter((child) => child.type === "table_option" &&
+                    /^COMMENT\s*=/i.test(child.text))
+                    .map((child) => {
+                    // The upstream grammar hides table-option string tokens; ownership comes from the complete option node.
+                    const offset = child.text.indexOf("=") + 1;
+                    const value = child.text.slice(offset);
+                    const whitespace = value.length - value.trimStart().length;
+                    return text.range(child.startIndex + offset + whitespace, child.endIndex);
+                });
+            for (const range of ranges) {
+                const id = `${source.id}:mysql-comment:${range.start.offset}`;
+                const mapped = MysqlDocumentation_1.MysqlDocumentation.read(source.content, range, id);
+                if (mapped === undefined) {
+                    analysis.complete = false;
+                    analysis.diagnostics.push({
+                        code: "mysql-comment-mode",
+                        severity: "error",
+                        message: "The MySQL COMMENT literal requires an unsupported string or server escape mode.",
+                        repair: "Use a single-quoted COMMENT literal with doubled apostrophes and no backslash escapes.",
+                        location: { file: source.physicalPath, range },
+                    });
+                    continue;
+                }
+                analysis.documentation.push({
+                    id,
+                    range,
+                    mapped,
+                    attachments: [{ declarationId: owner.id, siteId: owner.site.id }],
+                });
+            }
+        }
+        return analysis;
+    }
+    MysqlFileScanner.scan = scan;
+})(MysqlFileScanner || (exports.MysqlFileScanner = MysqlFileScanner = {}));
+/**
+ * Visits named syntax while keeping all attachment decisions local to declarations.
+ *
+ * String contents remain opaque because they are not grammar nodes in the traversal.
+ */
+function descendants(node) {
+    return [node, ...node.namedChildren.flatMap(descendants)];
+}

package/lib/adapters/mysql/MysqlIdentifier.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Defines source-spelled MySQL names without consulting server or filesystem settings.
+ *
+ * The adapter preserves this deterministic identity across hosts with different server policy.
+ */
+export declare namespace MysqlIdentifier {
+    /**
+     * Unquotes backticks and rejects other dialect delimiters or ANSI quotes.
+     *
+     * Their interpretation can depend on server configuration outside a source snapshot.
+     */
+    function read(raw: string): string | undefined;
+}

package/lib/adapters/mysql/MysqlIdentifier.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlIdentifier = void 0;
+/**
+ * Defines source-spelled MySQL names without consulting server or filesystem settings.
+ *
+ * The adapter preserves this deterministic identity across hosts with different server policy.
+ */
+var MysqlIdentifier;
+(function (MysqlIdentifier) {
+    /**
+     * Unquotes backticks and rejects other dialect delimiters or ANSI quotes.
+     *
+     * Their interpretation can depend on server configuration outside a source snapshot.
+     */
+    function read(raw) {
+        if (raw.includes("\0") || /[\uD800-\uDFFF]/.test(raw))
+            return undefined;
+        if (raw.startsWith("`")) {
+            if (!/^`(?:[^`]|``)+`$/u.test(raw))
+                return undefined;
+            const name = raw.slice(1, -1).replaceAll("``", "`");
+            return name.endsWith(" ") ? undefined : name;
+        }
+        return /^[A-Za-z_\u0080-\uFFFF][A-Za-z_0-9$\u0080-\uFFFF]*$/u.test(raw)
+            ? raw
+            : undefined;
+    }
+    MysqlIdentifier.read = read;
+})(MysqlIdentifier || (exports.MysqlIdentifier = MysqlIdentifier = {}));

package/lib/adapters/mysql/MysqlPolicy.d.ts

@@ -0,0 +1,39 @@
+import type { Node } from "web-tree-sitter";
+import { MysqlIdentifier } from "./MysqlIdentifier";
+/**
+ * Validates the explicitly selected MySQL CREATE TABLE source subset.
+ *
+ * Shared SQL extraction asks this policy to fail closed when syntax depends on server state.
+ */
+export declare namespace MysqlPolicy {
+    /**
+     * Retains source spelling independently of lower_case_table_names and host operating system.
+     *
+     * Snapshot identity cannot safely depend on a database server or filesystem setting.
+     */
+    const identifier: typeof MysqlIdentifier.read;
+    /**
+     * Ignores column REFERENCES because MySQL does not create a foreign key from that syntax.
+     *
+     * Only a table-level FOREIGN KEY declaration contributes a relation unit.
+     */
+    const inlineReferences: "ignore";
+    /**
+     * Ignores FOREIGN KEY index names when identifying MySQL relations.
+     *
+     * The endpoint tuple is stable while an index name does not name the constraint.
+     */
+    const constraintNames = false;
+    /**
+     * Places an unqualified REFERENCES target in its explicitly qualified owning database.
+     *
+     * This supplies a deterministic semantic path without consulting the current database.
+     */
+    function reference(target: string[], owner: string[]): string[];
+    /**
+     * Rejects environment state and syntax from the shared grammar's other dialects.
+     *
+     * Returning a reason makes the source analysis incomplete rather than partially inferred.
+     */
+    function validate(node: Node): string | undefined;
+}

package/lib/adapters/mysql/MysqlPolicy.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlPolicy = void 0;
+const MysqlIdentifier_1 = require("./MysqlIdentifier");
+/**
+ * Validates the explicitly selected MySQL CREATE TABLE source subset.
+ *
+ * Shared SQL extraction asks this policy to fail closed when syntax depends on server state.
+ */
+var MysqlPolicy;
+(function (MysqlPolicy) {
+    /**
+     * Retains source spelling independently of lower_case_table_names and host operating system.
+     *
+     * Snapshot identity cannot safely depend on a database server or filesystem setting.
+     */
+    MysqlPolicy.identifier = MysqlIdentifier_1.MysqlIdentifier.read;
+    /**
+     * Ignores column REFERENCES because MySQL does not create a foreign key from that syntax.
+     *
+     * Only a table-level FOREIGN KEY declaration contributes a relation unit.
+     */
+    MysqlPolicy.inlineReferences = "ignore";
+    /**
+     * Ignores FOREIGN KEY index names when identifying MySQL relations.
+     *
+     * The endpoint tuple is stable while an index name does not name the constraint.
+     */
+    MysqlPolicy.constraintNames = false;
+    /**
+     * Places an unqualified REFERENCES target in its explicitly qualified owning database.
+     *
+     * This supplies a deterministic semantic path without consulting the current database.
+     */
+    function reference(target, owner) {
+        return target.length === 1 && owner.length === 2
+            ? [...owner.slice(0, 1), ...target]
+            : target;
+    }
+    MysqlPolicy.reference = reference;
+    /**
+     * Rejects environment state and syntax from the shared grammar's other dialects.
+     *
+     * Returning a reason makes the source analysis incomplete rather than partially inferred.
+     */
+    function validate(node) {
+        if (node.type === "comment" || node.type === "marginalia") {
+            if (node.type === "comment" && !/^--(?:\s|$)/u.test(node.text))
+                return "MySQL line comments require whitespace after --; correct the source before checking coverage.";
+            return node.text.startsWith("/*!")
+                ? "MySQL executable comments can change the schema; supply their explicit CREATE TABLE declarations."
+                : undefined;
+        }
+        if (node.type !== "create_table")
+            return "MySQL supports explicit CREATE TABLE declarations only; materialize migrations, routines, dynamic SQL, views, and session-dependent schema state first.";
+        if (node.namedChildren.some((child) => !TABLE_CHILDREN.has(child.type)))
+            return "This MySQL table uses unsupported schema derivation or storage syntax; provide the documented explicit CREATE TABLE form.";
+        const nodes = descendants(node);
+        if (node.namedChildren.filter((child) => child.type === "table_option" && /^COMMENT\s*=/i.test(child.text)).length > 1)
+            return "Use one table COMMENT option so documentation has one unambiguous owner and value.";
+        if (nodes.some((child) => FORBIDDEN.has(child.type)))
+            return "This table uses an unsupported MySQL construct or syntax from another SQL dialect; provide the documented explicit table subset.";
+        for (const child of nodes) {
+            if (child.type === "literal" && child.text.startsWith("$"))
+                return "Dollar-quoted SQL literals are not MySQL source syntax; use a MySQL string literal.";
+            if (child.type === "cast" &&
+                child.children.some((token) => token.type === "::"))
+                return "PostgreSQL cast syntax is not MySQL source syntax; use a MySQL CAST expression.";
+            if (child.type === "identifier" && MysqlPolicy.identifier(child.text) === undefined)
+                return "Use supported MySQL names with BMP characters and no NUL or trailing spaces; only unquoted and backtick quoting is supported.";
+            if (child.type === "object_reference" &&
+                child.namedChildren.filter((item) => item.type === "identifier")
+                    .length > 2)
+                return "MySQL table names have at most database and table segments.";
+            if (child.type === "table_option") {
+                const message = tableOption(child);
+                if (message !== undefined)
+                    return message;
+            }
+        }
+        const definitions = nodes.filter((child) => child.type === "column_definition");
+        const names = new Set();
+        for (const column of definitions) {
+            if (column.namedChildren.some((child) => child.type === "direction"))
+                return "ASC and DESC belong to MySQL index columns, not ordinary column definitions.";
+            if (column.namedChildren.some((child) => child.type === "keyword_as"))
+                return "Generated MySQL columns are outside the explicit ordinary-column subset.";
+            if (column.namedChildren.filter((child) => child.type === "keyword_comment")
+                .length > 1)
+                return "Use one column COMMENT clause so documentation has one unambiguous value.";
+            const raw = column.childForFieldName("name")?.text;
+            const name = raw === undefined ? undefined : MysqlPolicy.identifier(raw);
+            if (name === undefined)
+                return "The MySQL column name is unsupported; use an explicit identifier.";
+            const folded = name.toLowerCase();
+            if (names.has(folded))
+                return "MySQL column names are case-insensitive; remove duplicate column declarations differing only by case.";
+            names.add(folded);
+            const type = column.childForFieldName("type")?.text;
+            if (type === undefined ||
+                !/^(?:(?:TINYINT|SMALLINT|MEDIUMINT|INT|INTEGER|BIGINT|DECIMAL|DEC|NUMERIC|FIXED|FLOAT|DOUBLE(?:\s+PRECISION)?|REAL|BIT|BOOL|BOOLEAN|CHAR|VARCHAR|BINARY|VARBINARY|TINYBLOB|BLOB|MEDIUMBLOB|LONGBLOB|TINYTEXT|TEXT|MEDIUMTEXT|LONGTEXT|DATE|TIME|DATETIME|TIMESTAMP|YEAR|JSON)(?:\s*\(\s*\d+(?:\s*,\s*\d+)?\s*\))?(?:\s+(?:UNSIGNED|ZEROFILL))*|(?:ENUM|SET)\s*\(\s*'(?:[^'\\]|'')*'(?:\s*,\s*'(?:[^'\\]|'')*')*\s*\))$/i.test(type))
+                return "The MySQL column type is outside the supported explicit built-in type subset.";
+        }
+        return undefined;
+    }
+    MysqlPolicy.validate = validate;
+})(MysqlPolicy || (exports.MysqlPolicy = MysqlPolicy = {}));
+/**
+ * Collects a statement's named syntax while keeping strings opaque.
+ *
+ * Policy validation must inspect grammar nodes without treating literal contents as SQL syntax.
+ */
+function descendants(node) {
+    return [node, ...node.namedChildren.flatMap(descendants)];
+}
+/**
+ * Accepts MySQL options whose schema and documentation ownership are static.
+ *
+ * Other options can depend on server behavior outside the selected source snapshot.
+ */
+function tableOption(node) {
+    const raw = node.text;
+    if (/^ENGINE\s*=\s*(?:InnoDB|NDB|NDBCLUSTER|MyISAM|MEMORY|CSV|ARCHIVE|BLACKHOLE)\s*$/i.test(raw))
+        return undefined;
+    if (/^COMMENT\s*=\s*'(?:[^'\\]|'')*'\s*$/is.test(raw))
+        return undefined;
+    if (/^(?:DEFAULT\s+CHARACTER\s+SET|COLLATE)\s+[A-Za-z0-9_]+\s*$/i.test(raw))
+        return undefined;
+    if (/^(?:CHARSET|COLLATE)\s*=\s*[A-Za-z0-9_]+\s*$/i.test(raw))
+        return undefined;
+    if (/^ROW_FORMAT\s*=\s*(?:DEFAULT|DYNAMIC|FIXED|COMPRESSED|REDUNDANT|COMPACT)\s*$/i.test(raw))
+        return undefined;
+    return "This MySQL table option is outside the supported ENGINE, COMMENT, character set, collation, and row-format subset.";
+}
+/**
+ * Lists syntax whose effects require state or semantics outside the declared subset.
+ *
+ * Validation uses this set to reject shared-grammar constructs before extraction.
+ */
+const FORBIDDEN = new Set([
+    "array",
+    "array_size_definition",
+    "keyword_nulls",
+    "keyword_temporary",
+    "keyword_temp",
+    "keyword_unlogged",
+    "keyword_external",
+    "keyword_if",
+    "keyword_generated",
+    "keyword_virtual",
+    "keyword_stored",
+    "keyword_inherits",
+    "keyword_partition",
+    "keyword_partitioned",
+    "select",
+    "select_expression",
+    "create_query",
+    "keyword_tablespace",
+]);
+/**
+ * Lists accepted direct syntax so unrelated shared-grammar dialect options fail closed.
+ *
+ * This boundary limits MySQL extraction to declarations with stable snapshot semantics.
+ */
+const TABLE_CHILDREN = new Set([
+    "keyword_create",
+    "keyword_table",
+    "object_reference",
+    "column_definitions",
+    "table_option",
+    "comment",
+    "marginalia",
+]);

package/lib/adapters/objc/EvidenceObjcAdapter.d.ts

@@ -0,0 +1,15 @@
+import { ObjcAdapter } from "./ObjcAdapter";
+/**
+ * Extracts explicit Objective-C interfaces, protocols, categories, and public members.
+ *
+ * Analysis includes declared properties, public ivars, and external C functions
+ * and attaches supported Doxygen to their physical sites. Protocol and category
+ * names remain literal owner segments. Method selectors preserve their plus or
+ * minus prefix and every colon, keeping class and instance methods distinguishable.
+ *
+ * Objective-C++, preprocessing, include traversal, external C aggregate/data
+ * declarations, compatibility aliases, and inherited or synthesized declarations
+ * are outside this selected-source boundary.
+ */
+export declare class EvidenceObjcAdapter extends ObjcAdapter {
+}

package/lib/adapters/objc/EvidenceObjcAdapter.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceObjcAdapter = void 0;
+const ObjcAdapter_1 = require("./ObjcAdapter");
+/**
+ * Extracts explicit Objective-C interfaces, protocols, categories, and public members.
+ *
+ * Analysis includes declared properties, public ivars, and external C functions
+ * and attaches supported Doxygen to their physical sites. Protocol and category
+ * names remain literal owner segments. Method selectors preserve their plus or
+ * minus prefix and every colon, keeping class and instance methods distinguishable.
+ *
+ * Objective-C++, preprocessing, include traversal, external C aggregate/data
+ * declarations, compatibility aliases, and inherited or synthesized declarations
+ * are outside this selected-source boundary.
+ */
+class EvidenceObjcAdapter extends ObjcAdapter_1.ObjcAdapter {
+}
+exports.EvidenceObjcAdapter = EvidenceObjcAdapter;