@m6d/cortex-server 1.8.0 → 2.0.1

package/README.md

@@ -1,6 +1,8 @@
 # @m6d/cortex-server
 
-Multi-agent AI chat server built on Hono + Bun. Supports MSSQL persistence, MinIO file storage, Neo4j knowledge graphs, and AI streaming with tool execution.
+Multi-agent AI chat server built on Hono + Bun. Supports MSSQL or Postgres persistence, MinIO file storage, Neo4j knowledge graphs, and AI streaming with tool execution.
+
+This package is a **runtime** library: it serves requests, resolves against the knowledge graph on every prompt, and exports the `define*` helpers you author domains with. Generation and seeding are not here — seeding the graph and generating endpoint schemas from Swagger are [`@m6d/cortex-cli`](https://www.npmjs.com/package/@m6d/cortex-cli) commands (`cortex graph seed`, `cortex swagger sync`). What the two share is the graph contract — `GRAPH_SCHEMA`, `GRAPH_SCHEMA_VERSION`, the `define*` helpers and their types, the Neo4j client and the embedder — which lives in the private `@cortex/contracts` workspace package (`internal/contracts`) and is vendored into this package's tarball at pack time. It is all re-exported from here, so authoring your domains stays one import. The CLI stamps the schema version it seeded onto the graph; this package reads that stamp on its first resolve and refuses a graph it cannot read, instead of quietly retrieving nothing.
 
 ## Usage
 
@@ -9,6 +11,7 @@ import { createCortex } from "@m6d/cortex-server";
 
 const cortex = createCortex({
     database: {
+        // Or `type: "postgres"` with a postgres:// connection string.
         type: "mssql",
         connectionString: process.env.DB_CONNECTION_STRING!,
     },
@@ -35,7 +38,7 @@ const cortex = createCortex({
         dimension: 1536,
     },
     neo4j: {
-        url: "bolt://localhost:7687",
+        url: "http://localhost:7474",
         user: "neo4j",
         password: "password",
     },
@@ -55,7 +58,9 @@ export default {
 };
 ```
 
-`cortex.serve()` is async — it runs database migrations on startup.
+`cortex.serve()` is async — it runs database migrations on startup, from the migration history belonging to the configured dialect.
+
+Only `database`, `model`, and `agents` are required for a minimal setup. `storage` enables attachment uploads/downloads, `embedding` is only required when `neo4j` graph features are configured, and agent `systemPrompt` defaults to an empty prompt when omitted. An optional `redis: { url, streamTtlSeconds? }` backs resumable streams with Redis so runs survive reconnects, reloads, and multiple server instances; without it an in-memory, single-process fallback is used.
 
 Each key in `agents` becomes a route prefix (e.g. `assistant` → `/agents/assistant/...`). Agents can define per-agent `systemPrompt`, `tools`, `backendFetch`, `loadSessionData`, `resolveRequestContext`, and lifecycle hooks (`onToolCall`, `onStreamFinish`).
 

package/contracts/README.md

@@ -0,0 +1,23 @@
+# @cortex/contracts
+
+The shapes both sides of a cortex boundary must agree on. Private on purpose —
+it never publishes; each publishable package carries its own copy:
+
+- `@m6d/cortex-server` and `@m6d/cortex-cli` publish raw source, so their
+  `prepack` vendors a copy of this directory into the tarball (`contracts/` and
+  `src/contracts/` respectively), resolved there by their shipped tsconfig paths.
+- `@m6d/cortex-angular` and `@m6d/cortex-react` compile the parts they import
+  into their build artifacts.
+
+Three boundaries, one subpath each:
+
+| import                      | boundary                                                      |
+| --------------------------- | ------------------------------------------------------------- |
+| `@cortex/contracts/wire`    | chat client ↔ server (HTTP/WebSocket types)                   |
+| `@cortex/contracts/runtime` | cortex-cc console ↔ server runtime API (zod schemas)          |
+| `@cortex/contracts/graph`   | graph authoring (cli) ↔ server (vocabulary, helpers, clients) |
+
+Everything is consumed as TypeScript source — no build, no dist. Nothing here
+has a runtime dependency beyond zod (for `/runtime`), and nothing here may grow
+one: these files are compiled into an Angular library, a React library, a CLI
+and a Bun server alike.

package/contracts/graph/embed.ts

@@ -0,0 +1,50 @@
+/**
+ * Embeddings, which both halves of the graph need: `@m6d/cortex-cli` embeds every
+ * concept description as it seeds, `@m6d/cortex-server` embeds every prompt as it
+ * resolves. Two embedders would mean two vector spaces, so there is one.
+ *
+ * TanStack AI removed embeddings, and the graph only ever needed the plain
+ * OpenAI-compatible `/embeddings` call cortex is already configured for — so this
+ * is a bare `fetch`, and this package keeps its zero dependencies.
+ *
+ * Everything under `./graph` is written to the oldest target any consumer builds
+ * against — an Angular library compiles these sources directly — and imports
+ * siblings by their `.js` specifier so one emit serves both `dist` and source.
+ */
+
+/** Everything cortex needs to reach one OpenAI-compatible embeddings endpoint. */
+export type EmbeddingProviderConfig = {
+    baseURL: string;
+    apiKey: string;
+    modelName: string;
+};
+
+/** Turns a batch of strings into their vectors, in the order given. */
+export type EmbedFn = (values: string[]) => Promise<number[][]>;
+
+export function createEmbedder(config: EmbeddingProviderConfig) {
+    const url = `${config.baseURL.replace(/\/+$/, "")}/embeddings`;
+
+    return async function embed(values: string[]) {
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${config.apiKey}`,
+            },
+            body: JSON.stringify({ model: config.modelName, input: values }),
+        });
+
+        if (!response.ok) {
+            throw new Error(
+                `Embedding request failed (${response.status}): ${await response.text()}`,
+            );
+        }
+
+        // The API is free to return entries out of order; `index` is authoritative.
+        const body = (await response.json()) as { data: { index: number; embedding: number[] }[] };
+        return [...body.data]
+            .sort((left, right) => left.index - right.index)
+            .map((entry) => entry.embedding);
+    };
+}

package/{src/lib → contracts}/graph/helpers.ts

@@ -1,5 +1,7 @@
 /**
- * Helper functions for building knowledge graph seed data.
+ * Helper functions for building knowledge graph seed data. Projects author
+ * domains with these; `@m6d/cortex-server` re-exports them so authoring needs
+ * exactly one import path.
  */
 
 import type {
@@ -9,11 +11,7 @@ import type {
     EndpointInput,
     RuleDef,
     ServiceDef,
-} from "./types.ts";
-
-// ---------------------------------------------------------------------------
-// Identity helpers
-// ---------------------------------------------------------------------------
+} from "./types";
 
 export function defineConcept(def: Omit<ConceptDef, "__brand">) {
     return { __brand: "concept" as const, ...def };
@@ -31,10 +29,6 @@ export function defineDomain(def: Omit<DomainDef, "__brand">) {
     return { __brand: "domain" as const, ...def };
 }
 
-// ---------------------------------------------------------------------------
-// Endpoint builder
-// ---------------------------------------------------------------------------
-
 export function defineEndpoint(input: EndpointInput) {
     const propertiesDescriptions = Object.fromEntries(
         Object.entries({

package/{src/lib → contracts}/graph/neo4j.ts

@@ -1,16 +1,11 @@
 /**
- * Configurable Neo4j HTTP client.
+ * Configurable Neo4j HTTP client, shared by the graph's writer and its reader.
  *
- * Replaces the hardcoded process.env-based client from packages/sample-backend.
- * All configuration is passed explicitly — no environment variables are read.
+ * All configuration is passed explicitly — no environment variables are read —
+ * and the transport is `fetch`, so this package stays dependency-free.
  */
 
-import type { EmbeddingModel } from "ai";
-import { embed } from "ai";
-
-// ---------------------------------------------------------------------------
-// Config types
-// ---------------------------------------------------------------------------
+import type { EmbedFn } from "./embed";
 
 export type Neo4jConfig = {
     url: string;
@@ -22,33 +17,21 @@ export type Neo4jClient = {
     query(cypher: string, parameters?: Record<string, unknown>): Promise<string>;
 };
 
-// ---------------------------------------------------------------------------
-// Client factory
-// ---------------------------------------------------------------------------
-
-export function createNeo4jClient(config: Neo4jConfig, embeddingModel?: EmbeddingModel) {
+export function createNeo4jClient(config: Neo4jConfig, embed?: EmbedFn) {
     async function query(cypher: string, parameters?: Record<string, unknown>) {
         // Auto-embed parameters whose keys start with '#'
         const embeddedParams = Object.keys(parameters ?? {}).filter((x) => x.startsWith("#"));
 
         if (embeddedParams.length) {
-            if (!embeddingModel) {
-                throw new Error("An embedding model is required when using # parameters");
+            if (!embed) {
+                throw new Error("An embedder is required when using # parameters");
             }
 
-            const embeddingResults = await Promise.all(
-                embeddedParams.map(
-                    async (x) =>
-                        await embed({
-                            model: embeddingModel,
-                            value: parameters![x] as string,
-                        }),
-                ),
-            );
+            const embeddings = await embed(embeddedParams.map((k) => parameters![k] as string));
 
             embeddedParams.forEach((k, idx) => {
                 delete parameters![k];
-                parameters![k.slice(1)] = embeddingResults[idx]!.embedding;
+                parameters![k.slice(1)] = embeddings[idx]!;
             });
         }
 
@@ -77,13 +60,17 @@ export function createNeo4jClient(config: Neo4jConfig, embeddingModel?: Embeddin
         }
 
         const result = (await response.json()) as {
-            errors?: { message: string }[];
+            errors?: { code?: string; message: string }[];
             results: { columns: string[]; data: { row: unknown[] }[] }[];
         };
 
         if (result.errors && result.errors.length > 0) {
+            // `code` rides alongside the message rather than inside it: it is the
+            // one-line identifier a report shows, and existing readers of
+            // `message` keep seeing exactly what they saw before.
             return JSON.stringify({
                 error: true,
+                code: result.errors[0]!.code,
                 message: result.errors.map((e) => e.message).join("; "),
             });
         }

package/contracts/graph/schema.ts

@@ -0,0 +1,65 @@
+/**
+ * The contract between the graph's writer and its reader.
+ *
+ * Seeding lives in `@m6d/cortex-cli` and resolution lives in `@m6d/cortex-server`,
+ * two packages a project installs and upgrades separately. The labels, relationship
+ * types, property names and index name they agree on are this module, here, so
+ * neither side owns the vocabulary the other has to match.
+ *
+ * A mismatch between the two is invisible at runtime: the resolver's Cypher
+ * matches nothing and retrieval comes back empty rather than failing. That is what
+ * `GRAPH_SCHEMA_VERSION` is for — bump it on any change to the shape below. The
+ * CLI stamps the version it wrote onto the graph and the server checks that stamp
+ * on its first resolve, so skew surfaces as an error instead of as silence.
+ */
+
+export const GRAPH_SCHEMA_VERSION = 1;
+
+export const GRAPH_SCHEMA = {
+    label: {
+        domain: "Domain",
+        concept: "Concept",
+        endpoint: "Endpoint",
+        service: "Service",
+        rule: "Rule",
+        /** Stamped with the version above, so a stale graph is detectable later. */
+        marker: "CortexGraph",
+    },
+    rel: {
+        belongsTo: "BELONGS_TO",
+        specializes: "SPECIALIZES",
+        queriedVia: "QUERIED_VIA",
+        mutatedVia: "MUTATED_VIA",
+        returns: "RETURNS",
+        dependsOn: "DEPENDS_ON",
+        governs: "GOVERNS",
+        requestedVia: "REQUESTED_VIA",
+    },
+    prop: {
+        name: "name",
+        description: "description",
+        aliases: "aliases",
+        metadata: "metadata",
+        path: "path",
+        method: "method",
+        params: "params",
+        body: "body",
+        response: "response",
+        propertiesDescriptions: "propertiesDescriptions",
+        successStatus: "successStatus",
+        errorStatuses: "errorStatuses",
+        builtInId: "builtInId",
+        embedding: "embedding",
+        /** On a RETURNS edge: which part of the response carries the concept. */
+        field: "field",
+        /** On a DEPENDS_ON edge. */
+        paramName: "paramName",
+        fromField: "fromField",
+        /** On the marker node. */
+        version: "version",
+    },
+    /** Created by the CLI's seeder, queried by name in the resolver's first hop. */
+    conceptEmbeddingsIndex: "concept_embeddings",
+} as const;
+
+export type GraphSchema = typeof GRAPH_SCHEMA;

package/{src/lib → contracts}/graph/types.ts

@@ -7,10 +7,6 @@
  * - Services are concept associations (no hardcoded endpoint steps).
  */
 
-// ---------------------------------------------------------------------------
-// Endpoint property model (v2)
-// ---------------------------------------------------------------------------
-
 export type EndpointScalarType =
     | "uuid"
     | "number"
@@ -24,7 +20,8 @@ export type EndpointScalarType =
 export type EndpointProperty = {
     readonly name: string;
     readonly required: boolean;
-    readonly type: EndpointScalarType | string;
+    // NonNullable<unknown> keeps the literal union visible to autocomplete.
+    readonly type: EndpointScalarType | (string & NonNullable<unknown>);
     readonly isArray?: boolean;
     readonly properties?: readonly EndpointProperty[];
     readonly description?: string;
@@ -41,10 +38,6 @@ export type AutoGenerated = {
     readonly responseKind?: ResponseKind;
 };
 
-// ---------------------------------------------------------------------------
-// Concept descriptor
-// ---------------------------------------------------------------------------
-
 export type ConceptDef = {
     readonly __brand: "concept";
     name: string;
@@ -55,10 +48,6 @@ export type ConceptDef = {
     metadata?: Record<string, unknown>;
 };
 
-// ---------------------------------------------------------------------------
-// Endpoint descriptor (v2)
-// ---------------------------------------------------------------------------
-
 export type EndpointDef = {
     readonly __brand: "endpoint";
     name: string;
@@ -88,10 +77,6 @@ export type EndpointDef = {
     metadata?: Record<string, unknown>;
 };
 
-// ---------------------------------------------------------------------------
-// EndpointInput
-// ---------------------------------------------------------------------------
-
 export type EndpointInput = {
     name: string;
     path: string;
@@ -117,10 +102,6 @@ export type EndpointInput = {
     metadata?: Record<string, unknown>;
 };
 
-// ---------------------------------------------------------------------------
-// Service descriptor (v2)
-// ---------------------------------------------------------------------------
-
 export type ServiceDef = {
     readonly __brand: "service";
     name: string;
@@ -131,10 +112,6 @@ export type ServiceDef = {
     metadata?: Record<string, unknown>;
 };
 
-// ---------------------------------------------------------------------------
-// Rule descriptor
-// ---------------------------------------------------------------------------
-
 export type RuleDef = {
     readonly __brand: "rule";
     name: string;
@@ -142,10 +119,6 @@ export type RuleDef = {
     metadata?: Record<string, unknown>;
 };
 
-// ---------------------------------------------------------------------------
-// Domain descriptor
-// ---------------------------------------------------------------------------
-
 export type DomainDef = {
     readonly __brand: "domain";
     name: string;

package/contracts/graph.ts

@@ -0,0 +1,36 @@
+/**
+ * The graph contract — the knowledge-graph vocabulary, authoring types and
+ * clients that `@m6d/cortex-cli` writes with and `@m6d/cortex-server` reads
+ * with. `@m6d/cortex-server` re-exports all of it, so a project authoring
+ * domains still has exactly one import path.
+ */
+
+export type { GraphSchema } from "./graph/schema";
+export { GRAPH_SCHEMA, GRAPH_SCHEMA_VERSION } from "./graph/schema";
+
+export type {
+    EndpointScalarType,
+    EndpointProperty,
+    ResponseKind,
+    AutoGenerated,
+    ConceptDef,
+    EndpointDef,
+    EndpointInput,
+    ServiceDef,
+    RuleDef,
+    DomainDef,
+} from "./graph/types";
+
+export {
+    defineConcept,
+    defineRule,
+    defineService,
+    defineDomain,
+    defineEndpoint,
+} from "./graph/helpers";
+
+export type { Neo4jConfig, Neo4jClient } from "./graph/neo4j";
+export { createNeo4jClient } from "./graph/neo4j";
+
+export type { EmbedFn, EmbeddingProviderConfig } from "./graph/embed";
+export { createEmbedder } from "./graph/embed";

package/contracts/rich-text.ts

@@ -0,0 +1,207 @@
+/*
+ * The grammar and rendering pipeline for user-authored rich text that reaches
+ * the LLM (agent prompts, service descriptions). Both sides of the wire share
+ * it: the console edits and validates these strings, the console's runtime API
+ * pre-renders them (mentions + heading demotion), and `@m6d/cortex-server`
+ * applies per-request variable values. Two token grammars live here:
+ *
+ * - Tool mentions `@[name](uuid)` — the uuid is authoritative; the inline name
+ *   is only a display cache refreshed on save ({@link normalizeMentions}) and
+ *   resolved live when text is rendered for the LLM ({@link renderMentions}).
+ * - Variables `{{name}}` — validated against a known list at authoring time
+ *   ({@link analyzeVariables}) and substituted per request on the server
+ *   ({@link substituteVariables}).
+ */
+
+/** One mention token, unanchored and flagless — the editor's tokenizer anchors it, the helpers below add `g`. */
+export const MENTION_PATTERN_SOURCE = String.raw`@\[([^\]\n]*)\]\(([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\)`;
+
+const MENTION_PATTERN = new RegExp(MENTION_PATTERN_SOURCE, "g");
+
+const VARIABLE_PATTERN = /{{\s*([^{}]*?)\s*}}/g;
+
+export function extractMentionedToolIds(text: string) {
+    const ids: string[] = [];
+    for (const match of text.matchAll(MENTION_PATTERN)) {
+        const id = match[2];
+        if (id && !ids.includes(id)) ids.push(id);
+    }
+    return ids;
+}
+
+/** Replaces each mention token with the tool's current name (falling back to the cached inline name). */
+export function renderMentions(text: string, toolNameById: ReadonlyMap<string, string>) {
+    return text.replace(MENTION_PATTERN, (_, cachedName: string, toolId: string) => {
+        return toolNameById.get(toolId) ?? cachedName;
+    });
+}
+
+/** Refreshes stale display names inside stored text, keeping the tokens intact. */
+export function normalizeMentions(text: string, toolNameById: ReadonlyMap<string, string>) {
+    return text.replace(MENTION_PATTERN, (token, _cachedName: string, toolId: string) => {
+        const name = toolNameById.get(toolId);
+        return name === undefined ? token : `@[${name}](${toolId})`;
+    });
+}
+
+/** Splits the `{{variables}}` referenced in a text into known and unknown ones. */
+export function analyzeVariables<Variable extends string>(
+    text: string,
+    known: ReadonlyArray<Variable>,
+) {
+    const referenced = new Set(
+        Array.from(text.matchAll(VARIABLE_PATTERN), ([, name]) => name?.trim()),
+    );
+
+    return {
+        variables: known.filter((variable) => referenced.has(variable)),
+        unknownVariables: [...referenced].filter(
+            (variable): variable is string =>
+                variable !== undefined &&
+                !known.some((knownVariable) => knownVariable === variable),
+        ),
+    };
+}
+
+/** Fills `{{variables}}` with per-request values; unknown names stay verbatim. */
+export function substituteVariables(text: string, values: Record<string, string>) {
+    return text.replace(/\{\{(\w+)\}\}/g, (match, name: string) => values[name] ?? match);
+}
+
+/**
+ * Line-by-line fence state, following CommonMark's fence rules: a fence line
+ * is indented at most three spaces; an opening backtick fence's info string
+ * may not contain backticks; and a fence closes only on the same marker
+ * character, with at least the opening run's length, followed by nothing but
+ * whitespace — so a `~~~` line, a shorter same-marker run, or a ```` ```js ````
+ * info line inside a backtick fence all stay code content.
+ */
+function fenceTracker() {
+    let fence: { marker: string; length: number } | null = null;
+    return (line: string) => {
+        const match = /^ {0,3}(`{3,}|~{3,})(.*)$/.exec(line);
+        const delimiter = match?.[1];
+        const rest = match?.[2] ?? "";
+        if (delimiter) {
+            const marker = delimiter.charAt(0);
+            if (fence) {
+                if (
+                    marker === fence.marker &&
+                    delimiter.length >= fence.length &&
+                    rest.trim() === ""
+                ) {
+                    fence = null;
+                    return "close";
+                }
+                return "inside";
+            }
+            if (marker === "`" && rest.includes("`")) return "outside";
+            fence = { marker, length: delimiter.length };
+            return "open";
+        }
+        return fence ? "inside" : "outside";
+    };
+}
+
+/** ATX heading, CommonMark-style: up to three leading spaces, `#` run closed by space or line end. */
+const ATX_HEADING = /^( {0,3})(#{1,6})(?=[ \t]|$)/;
+
+/** Setext underline: a run of `=` or `-` alone on its line, up to three leading spaces. */
+const SETEXT_UNDERLINE = /^ {0,3}(=+|-+)[ \t]*$/;
+
+/** The skeleton owns `##` and `###`, so user headings start three levels below it. */
+function demotedHashes(level: number) {
+    return "#".repeat(Math.min(level + 3, 6));
+}
+
+/**
+ * Whether a line can be the text of a setext heading — i.e. it is an ordinary
+ * paragraph line, not a blank, a fence, another heading, or the start of a
+ * different block (quote/list), in which case the underline below it is a
+ * thematic break or list content rather than a heading marker.
+ */
+function isSetextText(line: string) {
+    return (
+        line.trim() !== "" &&
+        !ATX_HEADING.test(line) &&
+        !SETEXT_UNDERLINE.test(line) &&
+        !/^ {0,3}(`{3,}|~{3,})/.test(line) &&
+        !/^ {0,3}(>|[-*+][ \t]|\d+[.)][ \t])/.test(line)
+    );
+}
+
+/**
+ * Shifts user-authored headings down so they can never collide with the prompt
+ * skeleton, which owns `##` (sections) and `###` (card titles): `#` becomes
+ * `####`, deeper levels cap at `######`. Setext headings are rewritten as the
+ * equivalent demoted ATX heading, since two-level setext cannot express the
+ * shift. Fenced code is left alone.
+ */
+export function demoteHeadings(text: string) {
+    const lineState = fenceTracker();
+    const output: string[] = [];
+    for (const line of text.split("\n")) {
+        if (lineState(line) !== "outside") {
+            output.push(line);
+            continue;
+        }
+
+        const underline = SETEXT_UNDERLINE.exec(line)?.[1];
+        const previous = output[output.length - 1];
+        if (underline !== undefined && previous !== undefined && isSetextText(previous)) {
+            const level = underline.startsWith("=") ? 1 : 2;
+            output[output.length - 1] = `${demotedHashes(level)} ${previous.trim()}`;
+            continue;
+        }
+
+        output.push(
+            line.replace(ATX_HEADING, (_, indent: string, hashes: string) => {
+                return `${indent}${demotedHashes(hashes.length)}`;
+            }),
+        );
+    }
+    return output.join("\n");
+}
+
+/** The one render step for LLM-bound rich text: resolve mentions, then demote headings. */
+export function renderRichText(text: string, toolNameById: ReadonlyMap<string, string>) {
+    return demoteHeadings(renderMentions(text, toolNameById));
+}
+
+/**
+ * Reduces rich text to plain prose for embeddings: mentions become tool names
+ * (cached inline names when no map is given) and markdown syntax is dropped.
+ * ponytail: a regex stripper, not a markdown parser — nested emphasis or exotic
+ * constructs may leave residue; swap in a real parser if retrieval quality
+ * ever shows it.
+ */
+export function stripToPlaintext(
+    text: string,
+    toolNameById: ReadonlyMap<string, string> = new Map(),
+) {
+    const lineState = fenceTracker();
+    return renderMentions(text, toolNameById)
+        .split("\n")
+        .filter((line) => {
+            const state = lineState(line);
+            return state !== "open" && state !== "close";
+        })
+        .map((line) =>
+            line
+                .replace(/^ {0,3}#{1,6}[ \t]+/, "")
+                .replace(SETEXT_UNDERLINE, "")
+                .replace(/^\s{0,3}(>\s?)+/, "")
+                .replace(/^(\s*)([-*+]|\d+[.)])\s+/, "$1")
+                .replace(/^\s*([-*_]\s*){3,}$/, ""),
+        )
+        .join("\n")
+        .replace(/!\[([^\]]*)\]\([^)]*\)/g, "$1")
+        .replace(/\[([^\]]*)\]\([^)]*\)/g, "$1")
+        .replace(/(\*\*|__)([^*_]+)\1/g, "$2")
+        .replace(/(^|\W)[*_]([^*_]+)[*_](?=\W|$)/gm, "$1$2")
+        .replace(/~~([^~]+)~~/g, "$1")
+        .replace(/`([^`]*)`/g, "$1")
+        .replace(/\\([\\*_#[\]()>!`~+.-])/g, "$1")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}