rea-agents 3.0.0 → 3.2.0

package/dist/server/registerEvidenceResources.js

@@ -1,315 +0,0 @@
-import { ResourceNotFoundError, ResourceTemplate, } from "@modelcontextprotocol/server";
-import { createHash } from "node:crypto";
-import canonicalize from "canonicalize";
-import { registerJavaScriptApplicationGraphResource } from "./registerJavaScriptApplicationGraphResource.js";
-import { registerReconstructionObligationLedgerResource } from "./registerReconstructionObligationLedgerResource.js";
-import { registerReconstructionReadinessResource } from "./registerReconstructionReadinessResource.js";
-/** Expose immutable session-owned Evidence v2 records as MCP resources. */
-export const registerEvidenceResources = (server, session) => {
-    registerReconstructionCoverageResource(server, session);
-    registerInvestigationWorkspaceResource(server, session);
-    registerSessionEvidenceResource(server, session);
-    registerEvidenceBundleResource(server, session);
-    registerAnalysisSnapshotResource(server, session);
-    registerArtifactPageResource(server, session);
-    registerFunctionDossierResource(server, session);
-    registerEvidenceSectionResource(server, session);
-    registerReconstructionObligationLedgerResource(server, session);
-    registerReconstructionReadinessResource(server, session);
-    registerJavaScriptApplicationGraphResource(server, session);
-    registerResidualUnknownResource(server, session);
-    session.onAnalysisSnapshotChanged?.(() => {
-        void server.server
-            .sendResourceUpdated({ uri: "rea://snapshot/current" })
-            .catch(() => undefined);
-    });
-};
-const registerReconstructionCoverageResource = (server, session) => {
-    server.registerResource("reconstruction-coverage-revision", new ResourceTemplate("rea://reconstruction-coverage/{workspaceId}/revision/{revision}", {
-        list: undefined,
-    }), {
-        title: "Reconstruction coverage revision",
-        description: "Canonical CAS-linked surfaces, owners, claims, verifiers, evidence, and completion boundaries.",
-        mimeType: "application/json",
-    }, (uri, variables) => {
-        const workspaceId = stringVariable(variables.workspaceId, uri.href);
-        const revisionText = stringVariable(variables.revision, uri.href);
-        if (!/^\d+$/u.test(revisionText))
-            throw new ResourceNotFoundError(uri.href);
-        const workspace = session.reconstructionCoverageWorkspace(workspaceId, Number(revisionText));
-        if (workspace === undefined)
-            throw new ResourceNotFoundError(uri.href);
-        return jsonResource(uri.href, workspace);
-    });
-};
-const registerInvestigationWorkspaceResource = (server, session) => {
-    server.registerResource("investigation-workspace-revision", new ResourceTemplate("rea://workspace/{workspaceId}/revision/{revision}", {
-        list: undefined,
-    }), {
-        title: "Investigation workspace revision",
-        description: "Immutable session-retained workspace with CAS linkage.",
-        mimeType: "application/json",
-    }, (uri, variables) => {
-        const workspaceId = stringVariable(variables.workspaceId, uri.href);
-        const revisionText = stringVariable(variables.revision, uri.href);
-        if (!/^\d+$/u.test(revisionText))
-            throw new ResourceNotFoundError(uri.href);
-        const workspace = session.investigationWorkspace(workspaceId, Number(revisionText));
-        if (workspace === undefined)
-            throw new ResourceNotFoundError(uri.href);
-        return jsonResource(uri.href, workspace);
-    });
-};
-const registerSessionEvidenceResource = (server, session) => {
-    server.registerResource("session-evidence", new ResourceTemplate("rea://evidence/{evidenceId}", {
-        list: undefined,
-    }), {
-        title: "Session evidence",
-        description: "Immutable Evidence v2 records owned by this REA session.",
-        mimeType: "application/json",
-    }, (uri, variables) => {
-        const evidenceId = variables.evidenceId;
-        if (typeof evidenceId !== "string")
-            throw new ResourceNotFoundError(uri.href);
-        const evidence = session.evidenceById(evidenceId);
-        if (evidence === undefined)
-            throw new ResourceNotFoundError(uri.href);
-        return {
-            contents: [
-                {
-                    uri: uri.href,
-                    mimeType: "application/json",
-                    text: JSON.stringify(evidence, null, 2),
-                },
-            ],
-        };
-    });
-};
-const registerEvidenceBundleResource = (server, session) => {
-    server.registerResource("evidence-bundle", new ResourceTemplate("rea://evidence-bundle/{bundleDigest}", {
-        list: undefined,
-    }), {
-        title: "Evidence bundle",
-        description: "Immutable session-retained canonical Evidence v2 bundle.",
-        mimeType: "application/json",
-    }, (uri, variables) => {
-        const digest = stringVariable(variables.bundleDigest, uri.href);
-        if (!/^[a-f0-9]{64}$/u.test(digest))
-            throw new ResourceNotFoundError(uri.href);
-        const text = session.retainedEvidenceBundle(digest);
-        if (text === undefined)
-            throw new ResourceNotFoundError(uri.href);
-        return {
-            contents: [
-                {
-                    uri: uri.href,
-                    mimeType: "application/json",
-                    text,
-                },
-            ],
-        };
-    });
-};
-const registerAnalysisSnapshotResource = (server, session) => {
-    server.registerResource("analysis-snapshot", "rea://snapshot/current", {
-        title: "Analysis snapshot",
-        description: "Mutable provider-neutral analysis snapshot for the current native target.",
-        mimeType: "application/json",
-    }, (uri) => {
-        const snapshot = session.exportAnalysisSnapshot();
-        if (!snapshot.ok)
-            return jsonResource(uri.href, {
-                state: "unavailable",
-                reason: snapshot.error.message,
-                remediation: "Open a native target with a concrete analysis profile. After metadata mutation, call open_binary again for the current target to begin a fresh cache.",
-            });
-        return jsonResource(uri.href, {
-            state: "available",
-            target: snapshot.value.target,
-            profile: snapshot.value.binding,
-            content_digest: contentDigest(snapshot.value),
-            entry_count: snapshot.value.entries.length,
-            snapshot: snapshot.value,
-        });
-    });
-};
-const registerArtifactPageResource = (server, session) => {
-    server.registerResource("artifact-page", new ResourceTemplate("rea://artifact/{manifestId}/{collection}", {
-        list: undefined,
-        complete: {
-            collection: (prefix) => ["nodes", "occurrences", "edges"].filter((value) => value.startsWith(prefix)),
-        },
-    }), {
-        title: "Artifact graph page",
-        description: "Deterministically paged artifact graph collection.",
-        mimeType: "application/json",
-    }, (uri, variables) => {
-        const manifestId = stringVariable(variables.manifestId, uri.href);
-        const collection = stringVariable(variables.collection, uri.href);
-        if (!ARTIFACT_COLLECTIONS.has(collection))
-            throw new ResourceNotFoundError(uri.href);
-        const evidence = session
-            .exportEvidenceBundle()
-            .records.find((record) => artifactManifestId(record.normalized_result) === manifestId);
-        if (evidence === undefined)
-            throw new ResourceNotFoundError(uri.href);
-        const result = objectValue(evidence.normalized_result);
-        const page = result?.[collection];
-        if (page === undefined)
-            throw new ResourceNotFoundError(uri.href);
-        return jsonResource(uri.href, {
-            evidence_id: evidence.evidence_id,
-            manifest_id: manifestId,
-            collection,
-            page,
-            provider: evidence.provider,
-            limitations: evidence.limitations,
-        });
-    });
-};
-const registerFunctionDossierResource = (server, session) => {
-    server.registerResource("function-dossier", new ResourceTemplate("rea://function/{targetSha256}/{address}", {
-        list: undefined,
-    }), {
-        title: "Function dossier",
-        description: "Session-owned analyze_function dossier with provenance.",
-        mimeType: "application/json",
-    }, (uri, variables) => {
-        const targetSha256 = stringVariable(variables.targetSha256, uri.href);
-        const address = stringVariable(variables.address, uri.href);
-        const evidence = session
-            .exportEvidenceBundle()
-            .records.find((record) => record.operation === "analyze_function" &&
-            record.subject?.digest.sha256 === targetSha256 &&
-            functionAddress(record.normalized_result) === address);
-        if (evidence === undefined)
-            throw new ResourceNotFoundError(uri.href);
-        return jsonResource(uri.href, evidence);
-    });
-};
-const registerEvidenceSectionResource = (server, session) => {
-    server.registerResource("evidence-section", new ResourceTemplate("rea://evidence/{evidenceId}/section/{section}", {
-        list: undefined,
-        complete: {
-            section: (prefix) => EVIDENCE_SECTIONS.filter((section) => section.startsWith(prefix)),
-        },
-    }), {
-        title: "Evidence section",
-        description: "One independently useful bounded section of session Evidence v2.",
-        mimeType: "application/json",
-    }, (uri, variables) => {
-        const evidenceId = stringVariable(variables.evidenceId, uri.href);
-        const section = stringVariable(variables.section, uri.href);
-        const evidence = session.evidenceById(evidenceId);
-        if (evidence === undefined)
-            throw new ResourceNotFoundError(uri.href);
-        const value = evidenceSection(evidence.normalized_result, section);
-        if (value === undefined)
-            throw new ResourceNotFoundError(uri.href);
-        return jsonResource(uri.href, {
-            evidence_id: evidence.evidence_id,
-            operation: evidence.operation,
-            authority: evidence.authority,
-            confidence: evidence.confidence,
-            provider: evidence.provider,
-            limitations: evidence.limitations,
-            section,
-            value,
-        });
-    });
-};
-const registerResidualUnknownResource = (server, session) => {
-    server.registerResource("residual-unknown", new ResourceTemplate("rea://unknown/{unknownId}", {
-        list: undefined,
-    }), {
-        title: "Residual unknown",
-        description: "Current session-owned residual unknown head.",
-        mimeType: "application/json",
-    }, (uri, variables) => {
-        const unknownId = stringVariable(variables.unknownId, uri.href);
-        const unknown = session
-            .listUnknowns()
-            .find(({ unknown_id }) => unknown_id === unknownId);
-        if (unknown === undefined)
-            throw new ResourceNotFoundError(uri.href);
-        const history = session
-            .exportEvidenceBundle()
-            .unknowns.filter(({ unknown_id }) => unknown_id === unknownId);
-        return jsonResource(uri.href, { current: unknown, history });
-    });
-};
-const EVIDENCE_SECTIONS = [
-    "result",
-    "terminal",
-    "filesystem",
-    "process",
-    "protocol",
-    "nodes",
-    "occurrences",
-    "edges",
-];
-const stringVariable = (value, uri) => {
-    if (typeof value !== "string")
-        throw new ResourceNotFoundError(uri);
-    return value;
-};
-const evidenceSection = (result, section) => {
-    if (section === "result")
-        return result;
-    if (typeof result !== "object" || result === null || Array.isArray(result))
-        return undefined;
-    if (section === "terminal")
-        return pick(result, ["frames", "rendered_frames", "interaction_events"]);
-    if (section === "filesystem")
-        return pick(result, [
-            "filesystem_checkpoints",
-            "filesystem_effects",
-            "files_before",
-            "files_after",
-        ]);
-    if (section === "process")
-        return pick(result, ["process_samples", "exit", "settlement", "cleanup"]);
-    if (section === "protocol")
-        return pick(result, [
-            "protocol_events",
-            "replay_transitions",
-            "shim_events",
-        ]);
-    const value = result[section];
-    return value === undefined ? undefined : value;
-};
-const pick = (result, names) => {
-    const entries = names.flatMap((name) => result[name] === undefined ? [] : [[name, result[name]]]);
-    return entries.length === 0 ? undefined : Object.fromEntries(entries);
-};
-const jsonResource = (uri, value) => ({
-    contents: [
-        {
-            uri,
-            mimeType: "application/json",
-            text: JSON.stringify(value, null, 2),
-        },
-    ],
-});
-const ARTIFACT_COLLECTIONS = new Set(["nodes", "occurrences", "edges"]);
-const objectValue = (value) => typeof value === "object" && value !== null && !Array.isArray(value)
-    ? value
-    : undefined;
-const artifactManifestId = (value) => {
-    const manifest = objectValue(objectValue(value)?.manifest ?? null);
-    return typeof manifest?.manifest_id === "string"
-        ? manifest.manifest_id
-        : undefined;
-};
-const functionAddress = (value) => {
-    const result = objectValue(value);
-    const procedure = objectValue(result?.procedure ?? null);
-    const candidate = procedure?.address ?? result?.address;
-    return typeof candidate === "string" ? candidate : undefined;
-};
-const contentDigest = (value) => {
-    const encoded = canonicalize(value);
-    if (encoded === undefined)
-        throw new TypeError("Resource is not canonical JSON");
-    return createHash("sha256").update(encoded).digest("hex");
-};

package/dist/server/registerJavaScriptApplicationGraphResource.js

@@ -1,65 +0,0 @@
-import { ResourceNotFoundError, ResourceTemplate, } from "@modelcontextprotocol/server";
-import { javascriptApplicationAnalysisResultSchema } from "../domain/javascriptApplicationAnalysis.js";
-/** Register deterministic pages over one authenticated JavaScript graph. */
-export const registerJavaScriptApplicationGraphResource = (server, session) => {
-    server.registerResource("javascript-application-graph-page", new ResourceTemplate("rea://evidence/{evidenceId}/application-graph/{collection}/offset/{offset}/limit/{limit}", {
-        list: undefined,
-        complete: {
-            collection: (prefix) => ["nodes", "edges"].filter((name) => name.startsWith(prefix)),
-        },
-    }), {
-        title: "JavaScript application graph page",
-        description: "One deterministic bounded node or edge page from authenticated JavaScript application Evidence.",
-        mimeType: "application/json",
-    }, (uri, variables) => {
-        const evidenceId = stringVariable(variables.evidenceId, uri.href);
-        const collection = stringVariable(variables.collection, uri.href);
-        if (collection !== "nodes" && collection !== "edges")
-            throw new ResourceNotFoundError(uri.href);
-        const offset = pageInteger(variables.offset, uri.href, 0, 100_000);
-        const limit = pageInteger(variables.limit, uri.href, 1, 500);
-        const evidence = session.evidenceById(evidenceId);
-        if (evidence === undefined ||
-            evidence.operation !== "analyze_javascript_application")
-            throw new ResourceNotFoundError(uri.href);
-        const analysis = javascriptApplicationAnalysisResultSchema.safeParse(evidence.normalized_result);
-        if (!analysis.success)
-            throw new ResourceNotFoundError(uri.href);
-        const values = analysis.data.graph[collection];
-        const items = values.slice(offset, offset + limit);
-        const nextOffset = offset + items.length;
-        return {
-            contents: [
-                {
-                    uri: uri.href,
-                    mimeType: "application/json",
-                    text: JSON.stringify({
-                        evidence_id: evidence.evidence_id,
-                        graph_id: analysis.data.graph.graph_id,
-                        collection,
-                        items,
-                        offset,
-                        limit,
-                        total: values.length,
-                        next_offset: nextOffset < values.length ? nextOffset : null,
-                        has_more: nextOffset < values.length,
-                    }, null, 2),
-                },
-            ],
-        };
-    });
-};
-const stringVariable = (value, uri) => {
-    if (typeof value !== "string")
-        throw new ResourceNotFoundError(uri);
-    return value;
-};
-const pageInteger = (value, uri, minimum, maximum) => {
-    const text = stringVariable(value, uri);
-    if (!/^\d+$/u.test(text))
-        throw new ResourceNotFoundError(uri);
-    const parsed = Number(text);
-    if (!Number.isSafeInteger(parsed) || parsed < minimum || parsed > maximum)
-        throw new ResourceNotFoundError(uri);
-    return parsed;
-};

package/dist/server/registerReconstructionObligationLedgerResource.js

@@ -1,32 +0,0 @@
-import { ResourceNotFoundError, ResourceTemplate, } from "@modelcontextprotocol/server";
-import { reconstructionObligationLedgerPageSchema } from "../domain/reconstructionObligationLedgerSchemas.js";
-/** Expose retained obligation-ledger pages as typed Evidence resources. */
-export const registerReconstructionObligationLedgerResource = (server, session) => {
-    server.registerResource("reconstruction-obligation-ledger-page", new ResourceTemplate("rea://evidence/{evidenceId}/reconstruction-obligation-ledger", {
-        list: undefined,
-    }), {
-        title: "Reconstruction obligation ledger page",
-        description: "One deterministic Evidence v2-backed obligation page with full-ledger closure digest and summaries.",
-        mimeType: "application/json",
-    }, (uri, variables) => {
-        const evidenceId = variables.evidenceId;
-        if (typeof evidenceId !== "string")
-            throw new ResourceNotFoundError(uri.href);
-        const evidence = session.evidenceById(evidenceId);
-        if (evidence === undefined ||
-            evidence.predicate_type !== "rea.reconstruction-obligation-ledger/v1")
-            throw new ResourceNotFoundError(uri.href);
-        const page = reconstructionObligationLedgerPageSchema.safeParse(evidence.normalized_result);
-        if (!page.success)
-            throw new ResourceNotFoundError(uri.href);
-        return {
-            contents: [
-                {
-                    uri: uri.href,
-                    mimeType: "application/json",
-                    text: JSON.stringify({ evidence_id: evidence.evidence_id, page: page.data }, null, 2),
-                },
-            ],
-        };
-    });
-};

package/dist/server/registerReconstructionReadinessResource.js

@@ -1,32 +0,0 @@
-import { ResourceNotFoundError, ResourceTemplate, } from "@modelcontextprotocol/server";
-import { reconstructionReadinessReportSchema } from "../domain/reconstructionReadinessSchemas.js";
-/** Expose retained full readiness reports outside compact tool responses. */
-export const registerReconstructionReadinessResource = (server, session) => {
-    server.registerResource("reconstruction-readiness-report", new ResourceTemplate("rea://evidence/{evidenceId}/reconstruction-readiness-report", {
-        list: undefined,
-    }), {
-        title: "Reconstruction readiness report",
-        description: "Full deterministic nine-stage conformance report and replay identity.",
-        mimeType: "application/json",
-    }, (uri, variables) => {
-        const evidenceId = variables.evidenceId;
-        if (typeof evidenceId !== "string")
-            throw new ResourceNotFoundError(uri.href);
-        const evidence = session.evidenceById(evidenceId);
-        if (evidence === undefined ||
-            evidence.predicate_type !== "rea.reconstruction-readiness-report/v1")
-            throw new ResourceNotFoundError(uri.href);
-        const report = reconstructionReadinessReportSchema.safeParse(evidence.normalized_result);
-        if (!report.success)
-            throw new ResourceNotFoundError(uri.href);
-        return {
-            contents: [
-                {
-                    uri: uri.href,
-                    mimeType: "application/json",
-                    text: JSON.stringify({ evidence_id: evidence.evidence_id, report: report.data }, null, 2),
-                },
-            ],
-        };
-    });
-};

package/dist/server/toolInputValidation.js

@@ -1,77 +0,0 @@
-import { z } from "zod";
-import { AnalysisInputError, } from "../domain/errors.js";
-import { projectInputIssues } from "../domain/inputIssueProjection.js";
-import { err, ok } from "../domain/result.js";
-import { closeObjectSchemas } from "./toolRegistrationOptions.js";
-/** Parse one MCP request exactly once and retain only schema-owned correction data. */
-export const safeParseToolInput = (schema, input, operation) => {
-    const unknownIssues = unknownArgumentIssues(schema, input);
-    if (unknownIssues.length > 0)
-        return err(new AnalysisInputError(operation, undefined, unknownIssues));
-    const parsed = schema.safeParse(input);
-    return parsed.success
-        ? ok(parsed.data)
-        : err(new AnalysisInputError(operation, undefined, projectInputIssues(parsed.error.issues, input)));
-};
-const schemaCache = new WeakMap();
-const unknownArgumentIssues = (schema, input) => {
-    let jsonSchema = schemaCache.get(schema);
-    if (jsonSchema === undefined) {
-        const converter = schema["~standard"].jsonSchema?.input;
-        if (converter === undefined)
-            throw new TypeError("Tool input schema does not expose Standard JSON Schema");
-        jsonSchema = closeObjectSchemas(converter({ target: "draft-2020-12" }));
-        schemaCache.set(schema, jsonSchema);
-    }
-    return scanUnknownArguments(input, jsonSchema, jsonSchema, []);
-};
-const scanUnknownArguments = (value, schema, root, path) => {
-    const resolved = resolveSchema(schema, root);
-    if (Array.isArray(value)) {
-        const items = objectValue(resolved.items);
-        return items === undefined
-            ? []
-            : value.flatMap((item, index) => scanUnknownArguments(item, items, root, [...path, index]));
-    }
-    if (!isObject(value))
-        return [];
-    const variants = schemaVariants(resolved, root);
-    const properties = Object.fromEntries(variants.flatMap((variant) => Object.entries(objectValue(variant.properties) ?? {})));
-    const closed = variants.length > 0 &&
-        variants.every((variant) => variant.additionalProperties !== true &&
-            !isObject(variant.additionalProperties));
-    const issues = [];
-    for (const [key, child] of Object.entries(value)) {
-        const propertySchema = objectValue(properties[key]);
-        if (propertySchema === undefined) {
-            if (closed)
-                issues.push({ path: [...path, key], reason: "unknown_argument" });
-            continue;
-        }
-        issues.push(...scanUnknownArguments(child, propertySchema, root, [...path, key]));
-    }
-    return issues;
-};
-const schemaVariants = (schema, root) => {
-    const resolved = resolveSchema(schema, root);
-    const variants = [resolved.oneOf, resolved.anyOf, resolved.allOf]
-        .flatMap((value) => (Array.isArray(value) ? value : []))
-        .flatMap((value) => {
-        const object = objectValue(value);
-        return object === undefined ? [] : schemaVariants(object, root);
-    });
-    if (variants.length > 0)
-        return variants;
-    return resolved.type === "object" || isObject(resolved.properties)
-        ? [resolved]
-        : [];
-};
-const resolveSchema = (schema, root) => {
-    const reference = schema.$ref;
-    if (typeof reference !== "string" || !reference.startsWith("#/$defs/"))
-        return schema;
-    const definition = objectValue(objectValue(root.$defs)?.[reference.slice(8)]);
-    return definition === undefined ? schema : definition;
-};
-const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const objectValue = (value) => isObject(value) ? value : undefined;

package/scripts/package-runner-bootstrap.mjs

@@ -1,72 +0,0 @@
-import { spawn } from "node:child_process";
-import { resolve } from "node:path";
-
-const BOOTSTRAP_MARKER = "REA_PACKAGE_RUNNER_BOOTSTRAPPED";
-
-/**
- * Plan a current-release setup bootstrap when bare npx selected a project-local
- * package. Explicit `npm exec --package=<name>@<version>` rollbacks bypass it.
- */
-export function packageRunnerSetupPlan(input) {
-  if (input.args[0] !== "setup") return undefined;
-  if (input.environment[BOOTSTRAP_MARKER] === "1") return undefined;
-  if (input.environment.npm_lifecycle_event !== "npx") return undefined;
-
-  const localPrefix = input.environment.npm_config_local_prefix;
-  if (localPrefix === undefined || localPrefix.length === 0) return undefined;
-  if (
-    !isPackageBelowLocalPrefix(
-      input.packageRoot,
-      localPrefix,
-      input.packageName,
-    )
-  )
-    return undefined;
-
-  const requestedPackage = input.environment.npm_config_package;
-  if (
-    requestedPackage !== undefined &&
-    isExactPackageVersion(requestedPackage, input.packageName)
-  )
-    return undefined;
-
-  return {
-    command: "npm",
-    args: [
-      "exec",
-      "--yes",
-      `--package=${input.packageName}@latest`,
-      "--",
-      "rea",
-      ...input.args,
-    ],
-  };
-}
-
-/** Execute a planned package-runner bootstrap and return its exit status. */
-export async function runPackageRunnerSetupBootstrap(input) {
-  const plan = packageRunnerSetupPlan(input);
-  if (plan === undefined) return undefined;
-
-  return await new Promise((resolveExitCode) => {
-    const child = spawn(plan.command, plan.args, {
-      stdio: "inherit",
-      env: { ...input.environment, [BOOTSTRAP_MARKER]: "1" },
-    });
-    child.once("error", () => resolveExitCode(1));
-    child.once("exit", (code) => resolveExitCode(code ?? 1));
-  });
-}
-
-function isPackageBelowLocalPrefix(packageRoot, localPrefix, packageName) {
-  const expectedRoot = resolve(localPrefix, "node_modules", packageName);
-  return resolve(packageRoot) === expectedRoot;
-}
-
-function isExactPackageVersion(packageSpecifier, packageName) {
-  const version = packageSpecifier.slice(`${packageName}@`.length);
-  return (
-    packageSpecifier.startsWith(`${packageName}@`) &&
-    /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/u.test(version)
-  );
-}