@wrtnlabs/evidence 0.0.0 → 0.1.0

package/lib/adapters/prisma/EvidencePrismaFileScanner.js

@@ -0,0 +1,379 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidencePrismaFileScanner = void 0;
+const EvidenceSourceText_1 = require("../../internal/EvidenceSourceText");
+const EvidencePrismaSyntax_1 = require("./EvidencePrismaSyntax");
+const BLOCK_KEYWORDS = new Set([
+    "model",
+    "view",
+    "type",
+    "enum",
+    "datasource",
+    "generator",
+]);
+const MEMBER_BLOCKS = new Set(["model", "view", "type"]);
+/**
+ * Locates physical Prisma declarations and documentation without parsing
+ * semantics.
+ *
+ * The whole-schema parser remains responsible for deciding which declarations
+ * exist. This scanner supplies its source spans and comment-coordinate maps so
+ * those semantic declarations can own accurate sites and documentation.
+ */
+class EvidencePrismaFileScanner {
+    source;
+    /**
+     * Holds raw source lines in scan order, preserving a final empty line.
+     *
+     * Parallel coordinate arrays translate each line's local positions back to
+     * the immutable source snapshot.
+     */
+    lines;
+    /**
+     * Stores the UTF-16 offset at which each source line begins.
+     *
+     * Missing defensive entries fall back to the source boundary when malformed
+     * line state is encountered.
+     */
+    lineStarts = [];
+    /**
+     * Stores the UTF-16 offset immediately after each line's content.
+     *
+     * Carriage returns are excluded because declaration ranges use content-only
+     * line boundaries.
+     */
+    lineEnds = [];
+    /**
+     * Stores the offset of each line's newline character or line terminus.
+     *
+     * Comment-run maps use these positions for newlines introduced between
+     * fragments on different source lines.
+     */
+    newlineOffsets = [];
+    /**
+     * Translates scanner offsets into Evidence source ranges.
+     *
+     * All locations and comment carriers use this one coordinate authority.
+     */
+    text;
+    /**
+     * Initializes line and coordinate indexes for one immutable source snapshot.
+     *
+     * The scanner borrows no parser session because it deliberately recognizes
+     * only structural Prisma positions and comments.
+     */
+    constructor(source) {
+        this.source = source;
+        this.text = new EvidenceSourceText_1.EvidenceSourceText(source.content);
+        this.lines = source.content.split("\n");
+        let offset = 0;
+        for (const raw of this.lines) {
+            const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+            this.lineStarts.push(offset);
+            this.lineEnds.push(offset + line.length);
+            this.newlineOffsets.push(offset + raw.length);
+            offset += raw.length + 1;
+        }
+    }
+    /**
+     * Scans declaration positions and contiguous comment runs for the source.
+     *
+     * It flushes pending comments whenever syntax breaks adjacency, preserving
+     * detached carriers instead of attaching them to a later declaration.
+     */
+    scan() {
+        const locations = new Map();
+        const comments = [];
+        let pending = [];
+        let depth = 0;
+        let block = "";
+        let addressable = false;
+        let commented = false;
+        // A run is attached only at the next recognized location; all other syntax
+        // flushes it so a detached comment cannot document a later declaration.
+        const flush = (key) => {
+            comments.push(...this.runs(pending, key));
+            pending = [];
+        };
+        const record = (key, line) => {
+            if (key === "" || locations.has(key))
+                return;
+            locations.set(key, {
+                key,
+                range: this.text.range(this.lineStarts[line] ?? 0, this.lineEnds[line] ?? this.source.content.length),
+            });
+        };
+        for (let index = 0; index < this.lines.length; ++index) {
+            const parts = this.parts(index, commented);
+            commented = parts.commented;
+            const trimmed = parts.code.trim();
+            if (parts.comment !== undefined) {
+                parts.comment.topLevel = depth === 0;
+                parts.comment.trailing = trimmed !== "";
+                pending.push(parts.comment);
+            }
+            if (trimmed === "") {
+                if (parts.comment === undefined && depth === 0)
+                    flush("");
+                continue;
+            }
+            const opens = count(parts.code, "{");
+            const closes = count(parts.code, "}");
+            if (depth === 0 && opens !== 0) {
+                const head = blockHead(trimmed);
+                block = "";
+                addressable = false;
+                if (head === undefined)
+                    flush("");
+                else {
+                    block = head.name;
+                    addressable = MEMBER_BLOCKS.has(head.keyword);
+                    if (addressable)
+                        record(head.name, index);
+                    flush(head.name);
+                }
+            }
+            else if (depth === 1 && block !== "") {
+                const member = memberName(trimmed);
+                if (member === undefined)
+                    flush("");
+                else {
+                    if (addressable)
+                        record(`${block}.${member}`, index);
+                    flush(`${block}.${member}`);
+                }
+            }
+            else
+                flush("");
+            depth += opens - closes;
+            if (depth <= 0) {
+                depth = 0;
+                block = "";
+                addressable = false;
+            }
+        }
+        flush("");
+        return {
+            source: this.source,
+            locations: Array.from(locations.values()),
+            comments,
+        };
+    }
+    /**
+     * Separates code from a line comment while carrying block-comment state.
+     *
+     * Quotes suppress comment delimiters so URL-like and escaped string content
+     * cannot alter declaration scanning or comment attachment.
+     */
+    parts(line, initiallyCommented) {
+        const raw = this.lines[line] ?? "";
+        const content = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+        const start = this.lineStarts[line] ?? 0;
+        let code = "";
+        let form = initiallyCommented
+            ? "block"
+            : undefined;
+        let commented = initiallyCommented;
+        let quoted = false;
+        let commentStart = -1;
+        let commentEnd = -1;
+        let comment = "";
+        const offsets = [];
+        const ends = [];
+        for (let index = 0; index < content.length; ++index) {
+            const character = content[index] ?? "";
+            if (commented) {
+                if (commentStart < 0)
+                    commentStart = index;
+                if (character === "*" && content[index + 1] === "/") {
+                    commented = false;
+                    commentEnd = index + 2;
+                    ++index;
+                }
+                else {
+                    comment += character;
+                    offsets.push(start + index);
+                    ends.push(start + index + 1);
+                }
+                continue;
+            }
+            if (quoted) {
+                if (character === "\\")
+                    ++index;
+                else if (character === '"')
+                    quoted = false;
+                continue;
+            }
+            if (character === '"') {
+                quoted = true;
+                continue;
+            }
+            if (character === "/" && content[index + 1] === "/") {
+                commentStart = commentStart < 0 ? index : commentStart;
+                const documented = content[index + 2] === "/";
+                form ??= documented ? "doc" : "line";
+                index += documented ? 2 : 1;
+                for (++index; index < content.length; ++index) {
+                    comment += content[index] ?? "";
+                    offsets.push(start + index);
+                    ends.push(start + index + 1);
+                }
+                commentEnd = content.length;
+                break;
+            }
+            if (character === "/" && content[index + 1] === "*") {
+                commentStart = commentStart < 0 ? index : commentStart;
+                form ??= "block";
+                commented = true;
+                ++index;
+                continue;
+            }
+            code += character;
+        }
+        if (form === undefined)
+            return {
+                code,
+                commented,
+            };
+        if (commentEnd < 0)
+            commentEnd = content.length;
+        let trimmed = trimMapped(comment, offsets, ends);
+        if (form === "block" && trimmed.text.startsWith("*"))
+            trimmed = trimMapped(trimmed.text.slice(1), trimmed.offsets.slice(1), trimmed.ends.slice(1));
+        return {
+            code,
+            commented,
+            comment: {
+                form,
+                line,
+                text: trimmed.text,
+                offsets: trimmed.offsets,
+                ends: trimmed.ends,
+                range: this.text.range(start + Math.max(0, commentStart), start + commentEnd),
+                trailing: false,
+                topLevel: false,
+            },
+        };
+    }
+    /**
+     * Converts pending fragments into attached and detached documentation runs.
+     *
+     * Ordinary or trailing line comments remain separate carriers, while
+     * non-trailing documentation forms are grouped for one eligible key.
+     */
+    runs(pending, key) {
+        if (pending.length === 0)
+            return [];
+        const output = [];
+        const documenting = pending.filter((comment) => comment.form !== "line" && !comment.trailing);
+        for (const comment of pending)
+            if (comment.form === "line" || comment.trailing)
+                output.push(this.run([comment], "", false, comment.form));
+        if (documenting.length !== 0)
+            output.push(this.run(documenting, key, key === "" &&
+                documenting.every((comment) => comment.topLevel && comment.form === "doc"), "doc"));
+        return output;
+    }
+    /**
+     * Builds one mapped run from source-order comment fragments.
+     *
+     * Explicit newline entries preserve a continuous documentation string even
+     * when adjacent source comments occur on different lines.
+     */
+    run(comments, key, fileLevel, form) {
+        const first = comments[0];
+        const last = comments.at(-1);
+        if (first === undefined || last === undefined)
+            throw new Error("A Prisma comment run cannot be empty.");
+        const byLine = new Map(comments.map((comment) => [comment.line, comment]));
+        let text = "";
+        const offsets = [];
+        const ends = [];
+        for (let line = first.line; line <= last.line; ++line) {
+            const comment = byLine.get(line);
+            if (comment !== undefined) {
+                text += comment.text;
+                offsets.push(...comment.offsets);
+                ends.push(...comment.ends);
+            }
+            if (line !== last.line) {
+                const newline = this.newlineOffsets[line] ?? this.source.content.length;
+                text += "\n";
+                offsets.push(newline);
+                ends.push(Math.min(newline + 1, this.source.content.length));
+            }
+        }
+        offsets.push(ends.at(-1) ?? last.range.end.offset);
+        return {
+            form,
+            key,
+            fileLevel,
+            text,
+            offsets,
+            ends,
+            range: this.text.range(first.range.start.offset, last.range.end.offset),
+            commentRanges: comments.map((comment) => comment.range),
+        };
+    }
+}
+exports.EvidencePrismaFileScanner = EvidencePrismaFileScanner;
+/**
+ * Recognizes a top-level Prisma block header from structural source text.
+ *
+ * It accepts only known block keywords and valid identifiers, leaving semantic
+ * acceptance to Prisma's whole-schema parser.
+ */
+function blockHead(line) {
+    const fields = line.split(/\s+/u);
+    const keyword = fields[0];
+    const second = fields[1];
+    const name = second === undefined ? undefined : second.replace(/\{$/u, "");
+    if (keyword === undefined ||
+        name === undefined ||
+        !BLOCK_KEYWORDS.has(keyword) ||
+        !EvidencePrismaSyntax_1.EvidencePrismaSyntax.identifier(name))
+        return undefined;
+    return { keyword, name };
+}
+/**
+ * Extracts an addressable member name from one nested block line.
+ *
+ * Attribute and closing-brace lines cannot introduce member locations.
+ */
+function memberName(line) {
+    if (line.startsWith("@") || line.startsWith("}"))
+        return undefined;
+    const name = line.split(/\s+/u)[0];
+    return name !== undefined && EvidencePrismaSyntax_1.EvidencePrismaSyntax.identifier(name)
+        ? name
+        : undefined;
+}
+/**
+ * Counts occurrences of one structural character in code-only source text.
+ *
+ * Callers invoke this only after comment stripping, so braces inside comments
+ * cannot change scanner depth.
+ */
+function count(value, character) {
+    return Array.from(value).filter((candidate) => candidate === character)
+        .length;
+}
+/**
+ * Trims surrounding whitespace while preserving retained source coordinates.
+ *
+ * The returned arrays stay aligned with the shortened text, allowing later
+ * documentation mapping to identify every retained character precisely.
+ */
+function trimMapped(text, offsets, ends) {
+    const start = text.search(/\S/u);
+    if (start < 0)
+        return { text: "", offsets: [], ends: [] };
+    let end = text.length;
+    while (end > start && /\s/u.test(text[end - 1] ?? ""))
+        --end;
+    return {
+        text: text.slice(start, end),
+        offsets: offsets.slice(start, end),
+        ends: ends.slice(start, end),
+    };
+}

package/lib/adapters/prisma/EvidencePrismaModelLoader.d.ts

@@ -0,0 +1,13 @@
+import type { IEvidencePrismaLoadResult } from "./IEvidencePrismaLoadResult";
+import type { IEvidencePrismaSchemaFile } from "./IEvidencePrismaSchemaFile";
+/**
+ * Loads Prisma's resolved schema model through a consumer-compatible WASM
+ * bridge.
+ *
+ * The loader resolves the parser from the consumer first, caches complete
+ * schema-set outcomes by parser identity and content digest, and returns
+ * detached records that can outlive the WASM call.
+ */
+export declare namespace EvidencePrismaModelLoader {
+    function load(root: string, files: IEvidencePrismaSchemaFile[]): Promise<IEvidencePrismaLoadResult>;
+}

package/lib/adapters/prisma/EvidencePrismaModelLoader.js

@@ -0,0 +1,269 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidencePrismaModelLoader = void 0;
+const _assertGuard_1 = __importStar(require("typia/lib/internal/_assertGuard"));
+const node_crypto_1 = require("node:crypto");
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+const typia_1 = __importDefault(require("typia"));
+const EvidenceCanonicalJson_1 = require("../../internal/EvidenceCanonicalJson");
+const ANSI_PATTERN = /\x1b\[[0-9;]*m/gu;
+const CACHE_LIMIT = 16;
+const cache = new Map();
+/**
+ * Loads Prisma's resolved schema model through a consumer-compatible WASM
+ * bridge.
+ *
+ * The loader resolves the parser from the consumer first, caches complete
+ * schema-set outcomes by parser identity and content digest, and returns
+ * detached records that can outlive the WASM call.
+ */
+var EvidencePrismaModelLoader;
+(function (EvidencePrismaModelLoader) {
+    async function load(root, files) {
+        const parser = resolve(root);
+        const digest = schemaDigest(files);
+        const key = `${parser.origin}\0${parser.version}\0${digest}`;
+        const remembered = cache.get(key);
+        if (remembered !== undefined && remembered.models !== undefined)
+            return { models: structuredClone(remembered.models), digest };
+        if (remembered !== undefined && remembered.problem !== undefined)
+            throw new Error(remembered.problem);
+        let payload;
+        try {
+            payload = parser.getDatamodel(JSON.stringify({
+                prismaSchema: files.map((file) => [file.name, file.source.content]),
+            }));
+        }
+        catch (cause) {
+            const problem = `${failure(cause)} (parsed by @prisma/prisma-schema-wasm@${parser.version} resolved from the ${parser.origin})`;
+            remember(key, { problem });
+            throw new Error(problem);
+        }
+        let datamodel;
+        try {
+            datamodel = (() => {
+                const _ip0 = input => "string" === typeof input["name"];
+                const _ip1 = input => null === input["documentation"] || undefined === input["documentation"] || "string" === typeof input["documentation"];
+                const _ap0 = (input, _path, _exceptionable = true) => "string" === typeof input["name"] || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.json.assertParse",
+                    path: _path + ".name",
+                    expected: "string",
+                    value: input["name"]
+                }, _errorFactory);
+                const _ap1 = (input, _path, _exceptionable = true) => null === input["documentation"] || undefined === input["documentation"] || "string" === typeof input["documentation"] || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.json.assertParse",
+                    path: _path + ".documentation",
+                    expected: "(null | string | undefined)",
+                    value: input["documentation"]
+                }, _errorFactory);
+                const _ao0 = (input, _path, _exceptionable = true) => (Array.isArray(input.models) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.json.assertParse",
+                    path: _path + ".models",
+                    expected: "Array<IEvidencePrismaDatamodelModel>",
+                    value: input.models
+                }, _errorFactory)) && input.models.every((elem, _index3) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.json.assertParse",
+                    path: _path + ".models[" + _index3 + "]",
+                    expected: "IEvidencePrismaDatamodelModel",
+                    value: elem
+                }, _errorFactory)) && _ao1(elem, _path + ".models[" + _index3 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.json.assertParse",
+                    path: _path + ".models[" + _index3 + "]",
+                    expected: "IEvidencePrismaDatamodelModel",
+                    value: elem
+                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.json.assertParse",
+                    path: _path + ".models",
+                    expected: "Array<IEvidencePrismaDatamodelModel>",
+                    value: input.models
+                }, _errorFactory);
+                const _ao1 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && _ap1(input, _path, true && _exceptionable) && ((Array.isArray(input.fields) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.json.assertParse",
+                    path: _path + ".fields",
+                    expected: "Array<IEvidencePrismaDatamodelField>",
+                    value: input.fields
+                }, _errorFactory)) && input.fields.every((elem, _index4) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.json.assertParse",
+                    path: _path + ".fields[" + _index4 + "]",
+                    expected: "IEvidencePrismaDatamodelField",
+                    value: elem
+                }, _errorFactory)) && _ao2(elem, _path + ".fields[" + _index4 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.json.assertParse",
+                    path: _path + ".fields[" + _index4 + "]",
+                    expected: "IEvidencePrismaDatamodelField",
+                    value: elem
+                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.json.assertParse",
+                    path: _path + ".fields",
+                    expected: "Array<IEvidencePrismaDatamodelField>",
+                    value: input.fields
+                }, _errorFactory));
+                const _ao2 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && ("string" === typeof input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.json.assertParse",
+                    path: _path + ".kind",
+                    expected: "string",
+                    value: input.kind
+                }, _errorFactory)) && _ap1(input, _path, true && _exceptionable);
+                const _io0 = input => Array.isArray(input.models) && input.models.every(elem => "object" === typeof elem && null !== elem && _io1(elem));
+                const _io1 = input => _ip0(input) && _ip1(input) && (Array.isArray(input.fields) && input.fields.every(elem => "object" === typeof elem && null !== elem && _io2(elem)));
+                const _io2 = input => _ip0(input) && "string" === typeof input.kind && _ip1(input);
+                const __is = input => "object" === typeof input && null !== input && _io0(input);
+                let _errorFactory;
+                const __assert = (input, errorFactory) => {
+                    if (false === __is(input)) {
+                        _errorFactory = errorFactory;
+                        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _assertGuard_1._assertGuard(true, {
+                            method: "typia.json.assertParse",
+                            path: _path + "",
+                            expected: "IEvidencePrismaDatamodel",
+                            value: input
+                        }, _errorFactory)) && _ao0(input, _path + "", true) || _assertGuard_1._assertGuard(true, {
+                            method: "typia.json.assertParse",
+                            path: _path + "",
+                            expected: "IEvidencePrismaDatamodel",
+                            value: input
+                        }, _errorFactory))(input, "$input", true);
+                    }
+                    return input;
+                };
+                return (input, errorFactory) => __assert(JSON.parse(input), errorFactory);
+            })()(payload);
+        }
+        catch (cause) {
+            throw new Error(`The Prisma parser returned an incompatible datamodel payload: ${message(cause)}`);
+        }
+        const models = datamodel.models.map(model);
+        remember(key, { models });
+        return { models: structuredClone(models), digest };
+    }
+    EvidencePrismaModelLoader.load = load;
+    function model(input) {
+        return {
+            name: input.name,
+            documentation: input.documentation ?? "",
+            digest: EvidenceCanonicalJson_1.EvidenceCanonicalJson.digest(EvidenceCanonicalJson_1.EvidenceCanonicalJson.without(input, ["documentation", "fields"])),
+            fields: input.fields.map((field) => ({
+                name: field.name,
+                symbol: field.kind === "object" ? "relation" : "column",
+                documentation: field.documentation ?? "",
+                digest: EvidenceCanonicalJson_1.EvidenceCanonicalJson.digest(EvidenceCanonicalJson_1.EvidenceCanonicalJson.without(field, ["documentation"])),
+            })),
+        };
+    }
+    function resolve(root) {
+        const failures = [];
+        for (const origin of ["project", "package"]) {
+            try {
+                const resolver = origin === "project"
+                    ? (0, node_module_1.createRequire)(node_path_1.default.join(root, "package.json"))
+                    : (0, node_module_1.createRequire)(__filename);
+                const manifest = resolver("@prisma/prisma-schema-wasm/package.json");
+                const module = resolver("@prisma/prisma-schema-wasm");
+                if (typeof module !== "object" ||
+                    module === null ||
+                    !("get_datamodel" in module) ||
+                    typeof module.get_datamodel !== "function")
+                    throw new Error("the module exposes no get_datamodel function");
+                const getDatamodel = module.get_datamodel;
+                return {
+                    getDatamodel(parameters) {
+                        const output = getDatamodel(parameters);
+                        if (typeof output !== "string")
+                            throw new Error("the parser returned a non-string payload");
+                        return output;
+                    },
+                    version: version(manifest),
+                    origin,
+                };
+            }
+            catch (cause) {
+                failures.push(`${origin}: ${message(cause)}`);
+            }
+        }
+        throw new Error(`No Prisma schema parser could be resolved (${failures.join("; ")}).`);
+    }
+    function version(manifest) {
+        if (typeof manifest === "object" &&
+            manifest !== null &&
+            "version" in manifest &&
+            typeof manifest.version === "string")
+            return manifest.version;
+        return "unknown";
+    }
+    function schemaDigest(files) {
+        const hash = (0, node_crypto_1.createHash)("sha256");
+        for (const file of files) {
+            hash.update(file.name);
+            hash.update("\0");
+            hash.update(file.source.digest);
+            hash.update("\n");
+        }
+        return hash.digest("hex");
+    }
+    function remember(key, entry) {
+        if (cache.has(key))
+            return;
+        while (cache.size >= CACHE_LIMIT) {
+            const oldest = cache.keys().next().value;
+            if (oldest === undefined)
+                break;
+            cache.delete(oldest);
+        }
+        cache.set(key, structuredClone(entry));
+    }
+    function failure(cause) {
+        const raw = message(cause);
+        try {
+            const envelope = JSON.parse(raw);
+            if (typeof envelope === "object" &&
+                envelope !== null &&
+                "message" in envelope &&
+                typeof envelope.message === "string")
+                return envelope.message.replace(ANSI_PATTERN, "").trim();
+        }
+        catch {
+            // A non-JSON error already is the complete parser message.
+        }
+        return raw.replace(ANSI_PATTERN, "").trim();
+    }
+    function message(cause) {
+        return cause instanceof Error ? cause.message : String(cause);
+    }
+})(EvidencePrismaModelLoader || (exports.EvidencePrismaModelLoader = EvidencePrismaModelLoader = {}));

package/lib/adapters/prisma/EvidencePrismaSyntax.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Shared lexical rules that do not determine Prisma schema semantics.
+ *
+ * Target and position helpers use these checks for safe identifier spelling;
+ * the Prisma WASM parser remains the authority on whether a schema is valid.
+ */
+export declare namespace EvidencePrismaSyntax {
+    function identifier(value: string): boolean;
+}