next-md-negotiate 0.0.1 → 0.0.2

package/dist/cli.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+
+// bin/cli.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+var APP_ROUTE_HANDLER = `import { createMdHandler } from 'next-md-negotiate';
+import registry from '@/md.config';
+
+export const GET = createMdHandler(registry);
+`;
+var PAGES_API_HANDLER = `import { createMdApiHandler } from 'next-md-negotiate';
+import registry from '@/md.config';
+
+export default createMdApiHandler(registry);
+`;
+var MD_CONFIG = `import { createMdVersion } from 'next-md-negotiate';
+
+export default [
+  // createMdVersion('/products/[productId]', async ({ productId }) => {
+  //   return \`# Product \${productId}\`;
+  // }),
+];
+`;
+function main() {
+  const command = process.argv[2];
+  if (command !== "init") {
+    console.log("Usage: next-md-negotiate init");
+    process.exit(1);
+  }
+  const cwd = process.cwd();
+  const pkgPath = join(cwd, "package.json");
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (!deps["next"]) {
+        console.error('Error: "next" is not listed in package.json dependencies. Is this a Next.js project?');
+        process.exit(1);
+      }
+    } catch {
+    }
+  }
+  const useSrc = existsSync(join(cwd, "src", "app")) || existsSync(join(cwd, "src", "pages"));
+  const hasAppDir = existsSync(join(cwd, useSrc ? "src" : "", "app"));
+  const hasPagesDir = existsSync(join(cwd, useSrc ? "src" : "", "pages"));
+  if (!hasAppDir && !hasPagesDir) {
+    console.error(
+      "Error: Could not find app/ or pages/ directory. Make sure you are in a Next.js project root."
+    );
+    process.exit(1);
+  }
+  const configDir = useSrc ? join(cwd, "src") : cwd;
+  try {
+    if (hasAppDir) {
+      const appDir = join(cwd, useSrc ? "src" : "", "app");
+      const routeDir = join(appDir, "md-api", "[...path]");
+      const routePath = join(routeDir, "route.ts");
+      if (existsSync(routePath)) {
+        console.log("  Skipped app/md-api/[...path]/route.ts (already exists)");
+      } else {
+        mkdirSync(routeDir, { recursive: true });
+        writeFileSync(routePath, APP_ROUTE_HANDLER);
+        console.log("  Created app/md-api/[...path]/route.ts");
+      }
+    } else {
+      const pagesDir = join(cwd, useSrc ? "src" : "", "pages");
+      const apiDir = join(pagesDir, "api", "md-api");
+      const routePath = join(apiDir, "[...path].ts");
+      if (existsSync(routePath)) {
+        console.log("  Skipped pages/api/md-api/[...path].ts (already exists)");
+      } else {
+        mkdirSync(apiDir, { recursive: true });
+        writeFileSync(routePath, PAGES_API_HANDLER);
+        console.log("  Created pages/api/md-api/[...path].ts");
+      }
+    }
+    const configPath = join(configDir, "md.config.ts");
+    if (existsSync(configPath)) {
+      console.log("  Skipped md.config.ts (already exists)");
+    } else {
+      writeFileSync(configPath, MD_CONFIG);
+      console.log("  Created md.config.ts");
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`Error: Failed to write files \u2014 ${message}`);
+    process.exit(1);
+  }
+  let nextMajor = null;
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      const nextVersion = deps["next"];
+      if (nextVersion) {
+        const match = nextVersion.match(/(\d+)/);
+        if (match) nextMajor = parseInt(match[1], 10);
+      }
+    } catch {
+    }
+  }
+  console.log("\nNext step \u2014 add content negotiation:\n");
+  if (nextMajor !== null && nextMajor >= 16) {
+    console.log(`  Your project uses Next.js ${nextMajor}, so add a proxy.ts in your project root:
+`);
+    console.log("  // proxy.ts");
+    console.log("  import { createMarkdownProxy } from 'next-md-negotiate';");
+    console.log("");
+    console.log("  const md = createMarkdownProxy({");
+    console.log("    routes: ['/products/[productId]', '/blog/[slug]'],");
+    console.log("  });");
+    console.log("");
+    console.log("  export function proxy(request: Request) {");
+    console.log("    return md(request);");
+    console.log("  }");
+  } else if (nextMajor !== null && nextMajor >= 14 && hasAppDir) {
+    console.log(`  Your project uses Next.js ${nextMajor} with App Router, so add a middleware.ts in your project root:
+`);
+    console.log("  // middleware.ts");
+    console.log("  import { createMarkdownMiddleware } from 'next-md-negotiate';");
+    console.log("");
+    console.log("  const md = createMarkdownMiddleware({");
+    console.log("    routes: ['/products/[productId]', '/blog/[slug]'],");
+    console.log("  });");
+    console.log("");
+    console.log("  export function middleware(request: Request) {");
+    console.log("    return md(request);");
+    console.log("  }");
+  } else if (nextMajor !== null && hasPagesDir && !hasAppDir) {
+    console.log(`  Your project uses Next.js ${nextMajor} with Pages Router, so add rewrites to next.config.js:
+`);
+    console.log("  // next.config.js");
+    console.log("  import { createMarkdownRewrites } from 'next-md-negotiate';");
+    console.log("");
+    console.log("  export default {");
+    console.log("    async rewrites() {");
+    console.log("      return {");
+    console.log("        beforeFiles: createMarkdownRewrites({");
+    console.log("          routes: ['/products/[productId]', '/blog/[slug]'],");
+    console.log("        }),");
+    console.log("      };");
+    console.log("    },");
+    console.log("  };");
+  } else {
+    console.log("  Choose the integration method that fits your setup:\n");
+    console.log("  Next.js 16+        \u2192 proxy.ts       with createMarkdownProxy");
+    console.log("  Next.js 14-15 (App Router) \u2192 middleware.ts  with createMarkdownMiddleware");
+    console.log("  Pages Router       \u2192 next.config.js with createMarkdownRewrites");
+  }
+  console.log("\n  Then define your routes in md.config.ts");
+}
+main();

package/dist/index.cjs

@@ -0,0 +1,207 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createMarkdownMiddleware: () => createMarkdownMiddleware,
+  createMarkdownProxy: () => createMarkdownProxy,
+  createMarkdownRewrites: () => createMarkdownRewrites,
+  createMdApiHandler: () => createMdApiHandler,
+  createMdHandler: () => createMdHandler,
+  createMdVersion: () => createMdVersion
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/validatePattern.ts
+var VALID_PATTERN = /^(\/([a-zA-Z0-9_-]+|\[(\.\.\.)?[a-zA-Z_]+\]))+$|^\/$/;
+function validatePattern(pattern) {
+  if (!VALID_PATTERN.test(pattern)) {
+    throw new Error(
+      `Invalid route pattern: "${pattern}". Patterns must start with / and use [param] or [...param] for dynamic segments.`
+    );
+  }
+}
+
+// src/createMdVersion.ts
+function createMdVersion(pattern, handler) {
+  validatePattern(pattern);
+  return { pattern, handler };
+}
+
+// src/matchPath.ts
+var regexCache = /* @__PURE__ */ new Map();
+function compilePattern(pattern) {
+  const cached = regexCache.get(pattern);
+  if (cached) return cached;
+  const CATCHALL_TOKEN = "\0CATCHALL_";
+  const PARAM_TOKEN = "\0PARAM_";
+  let tokenized = pattern;
+  const catchAllNames = [];
+  const paramNames = [];
+  tokenized = tokenized.replace(/\[\.\.\.([a-zA-Z_]+)\]/g, (_, name) => {
+    catchAllNames.push(name);
+    return `${CATCHALL_TOKEN}${catchAllNames.length - 1}\0`;
+  });
+  tokenized = tokenized.replace(/\[([a-zA-Z_]+)\]/g, (_, name) => {
+    paramNames.push(name);
+    return `${PARAM_TOKEN}${paramNames.length - 1}\0`;
+  });
+  let regexStr = tokenized.replace(/[.*+?^${}()|\\]/g, "\\$&");
+  catchAllNames.forEach((name, i) => {
+    regexStr = regexStr.replace(`${CATCHALL_TOKEN}${i}\0`, `(?<${name}>.+)`);
+  });
+  paramNames.forEach((name, i) => {
+    regexStr = regexStr.replace(`${PARAM_TOKEN}${i}\0`, `(?<${name}>[^/]+)`);
+  });
+  const regex = new RegExp(`^${regexStr}$`);
+  regexCache.set(pattern, regex);
+  return regex;
+}
+function matchPath(pattern, path) {
+  const regex = compilePattern(pattern);
+  const match = path.match(regex);
+  if (!match) return null;
+  return match.groups ? { ...match.groups } : {};
+}
+
+// src/createMdHandler.ts
+function createMdHandler(registry) {
+  return async function GET(_req, { params }) {
+    const { path } = await params;
+    const incomingPath = "/" + path.join("/");
+    for (const route of registry) {
+      const match = matchPath(route.pattern, incomingPath);
+      if (match) {
+        try {
+          const markdown = await route.handler(match);
+          const headers = new Headers();
+          headers.set("Content-Type", "text/markdown; charset=utf-8");
+          return new Response(markdown, { status: 200, headers });
+        } catch (error) {
+          console.error("[next-md-negotiate] Handler error:", error);
+          return new Response("Internal Server Error", { status: 500 });
+        }
+      }
+    }
+    return new Response("Not Found", { status: 404 });
+  };
+}
+
+// src/createMdApiHandler.ts
+function createMdApiHandler(registry) {
+  return async function handler(req, res) {
+    const pathParam = req.query.path;
+    const pathSegments = Array.isArray(pathParam) ? pathParam : pathParam ? [pathParam] : [];
+    const incomingPath = "/" + pathSegments.join("/");
+    for (const route of registry) {
+      const match = matchPath(route.pattern, incomingPath);
+      if (match) {
+        try {
+          const markdown = await route.handler(match);
+          res.setHeader("Content-Type", "text/markdown; charset=utf-8");
+          res.status(200).end(markdown);
+          return;
+        } catch (error) {
+          console.error("[next-md-negotiate] Handler error:", error);
+          res.status(500).end("Internal Server Error");
+          return;
+        }
+      }
+    }
+    res.status(404).end("Not Found");
+  };
+}
+
+// src/createMarkdownRewrites.ts
+var MARKDOWN_ACCEPT_REGEX = ".*(text/markdown|application/markdown|text/x-markdown).*";
+function createMarkdownRewrites(options) {
+  const prefix = options.internalPrefix ?? "/md-api";
+  return options.routes.map((source) => {
+    validatePattern(source);
+    const rewritePath = source.replace(/\[\.\.\.([a-zA-Z_]+)\]/g, ":$1*").replace(/\[([a-zA-Z_]+)\]/g, ":$1");
+    return {
+      source: rewritePath,
+      has: [
+        {
+          type: "header",
+          key: "accept",
+          value: MARKDOWN_ACCEPT_REGEX
+        }
+      ],
+      destination: `${prefix}${rewritePath}`
+    };
+  });
+}
+
+// src/negotiateRequest.ts
+var MARKDOWN_TYPES = [
+  "text/markdown",
+  "application/markdown",
+  "text/x-markdown"
+];
+function negotiateRequest(request, options) {
+  const accept = request.headers.get("accept") ?? "";
+  const wantsMarkdown = MARKDOWN_TYPES.some((type) => accept.includes(type));
+  if (!wantsMarkdown) return null;
+  const url = new URL(request.url);
+  const pathname = url.pathname;
+  const prefix = options.internalPrefix ?? "/md-api";
+  for (const route of options.routes) {
+    if (matchPath(route, pathname)) {
+      return new URL(`${prefix}${pathname}`, url.origin);
+    }
+  }
+  return null;
+}
+
+// src/createRewriteHandler.ts
+function createRewriteHandler(options) {
+  for (const route of options.routes) {
+    validatePattern(route);
+  }
+  return (request) => {
+    const rewriteUrl = negotiateRequest(request, options);
+    if (!rewriteUrl) return void 0;
+    return new Response(null, {
+      headers: {
+        "x-middleware-rewrite": rewriteUrl.toString()
+      }
+    });
+  };
+}
+
+// src/createMarkdownProxy.ts
+function createMarkdownProxy(options) {
+  return createRewriteHandler(options);
+}
+
+// src/createMarkdownMiddleware.ts
+function createMarkdownMiddleware(options) {
+  return createRewriteHandler(options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createMarkdownMiddleware,
+  createMarkdownProxy,
+  createMarkdownRewrites,
+  createMdApiHandler,
+  createMdHandler,
+  createMdVersion
+});

package/dist/index.d.cts

@@ -0,0 +1,146 @@
+/**
+ * Extracts parameter names from a Next.js-style route pattern.
+ *
+ * '/products/[productId]'        → { productId: string }
+ * '/blog/[slug]'                 → { slug: string }
+ * '/docs/[section]/[page]'       → { section: string; page: string }
+ * '/docs/[...slug]'              → { slug: string }
+ */
+type ExtractParams<T extends string> = T extends `${string}[...${infer Param}]${infer Rest}` ? {
+    [K in Param]: string;
+} & ExtractParams<Rest> : T extends `${string}[${infer Param}]${infer Rest}` ? {
+    [K in Param]: string;
+} & ExtractParams<Rest> : {};
+interface MdVersionHandler {
+    pattern: string;
+    handler: (params: Record<string, string>) => Promise<string>;
+}
+
+/**
+ * Defines a markdown version for a route.
+ *
+ * @example
+ * createMdVersion('/products/[productId]', async ({ productId }) => {
+ *   const product = await getProduct(productId);
+ *   return `# ${product.name}\n\n${product.description}`;
+ * });
+ */
+declare function createMdVersion<T extends string>(pattern: T, handler: (params: ExtractParams<T>) => Promise<string>): MdVersionHandler;
+
+/**
+ * Creates a Next.js route handler for the catch-all `/md-api/[...path]` route.
+ *
+ * @example
+ * // app/md-api/[...path]/route.ts
+ * import { createMdHandler } from 'next-md-negotiate';
+ * import registry from '@/md.config';
+ *
+ * export const GET = createMdHandler(registry);
+ */
+declare function createMdHandler(registry: MdVersionHandler[]): (req: Request, ctx: {
+    params: Promise<{
+        path: string[];
+    }>;
+}) => Promise<Response>;
+
+interface NextApiRequest {
+    query: Record<string, string | string[] | undefined>;
+}
+interface NextApiResponse {
+    status(code: number): NextApiResponse;
+    setHeader(name: string, value: string): NextApiResponse;
+    end(body?: string): void;
+}
+/**
+ * Creates a Pages Router API handler for `pages/api/md-api/[...path].ts`.
+ *
+ * @example
+ * // pages/api/md-api/[...path].ts
+ * import { createMdApiHandler } from 'next-md-negotiate';
+ * import registry from '@/md.config';
+ *
+ * export default createMdApiHandler(registry);
+ */
+declare function createMdApiHandler(registry: MdVersionHandler[]): (req: NextApiRequest, res: NextApiResponse) => Promise<void>;
+
+interface MarkdownRewriteOptions {
+    routes: string[];
+    /** Internal route prefix. Defaults to '/md-api'. */
+    internalPrefix?: string;
+}
+/**
+ * Generates Next.js rewrite rules that redirect markdown requests
+ * to the catch-all handler.
+ *
+ * Translates Next.js [param] syntax to :param for rewrite rules.
+ *
+ * @example
+ * // next.config.ts
+ * import { createMarkdownRewrites } from 'next-md-negotiate';
+ *
+ * export default {
+ *   async rewrites() {
+ *     return {
+ *       beforeFiles: createMarkdownRewrites({
+ *         routes: ['/products/[productId]', '/blog/[slug]'],
+ *       }),
+ *     };
+ *   },
+ * };
+ */
+declare function createMarkdownRewrites(options: MarkdownRewriteOptions): {
+    source: string;
+    has: {
+        type: "header";
+        key: string;
+        value: string;
+    }[];
+    destination: string;
+}[];
+
+interface NegotiateOptions {
+    routes: string[];
+    internalPrefix?: string;
+}
+
+/**
+ * Creates a proxy handler for Next.js 16+ `proxy.ts`.
+ *
+ * Returns a rewrite response for markdown requests matching
+ * configured routes, or `undefined` to pass through.
+ *
+ * @example
+ * // proxy.ts
+ * import { createMarkdownProxy } from 'next-md-negotiate';
+ *
+ * const markdownProxy = createMarkdownProxy({
+ *   routes: ['/products/[productId]', '/blog/[slug]'],
+ * });
+ *
+ * export function proxy(request: Request) {
+ *   return markdownProxy(request);
+ * }
+ */
+declare function createMarkdownProxy(options: NegotiateOptions): (request: Request) => Response | undefined;
+
+/**
+ * Creates a middleware handler for Next.js 14-15 `middleware.ts`.
+ *
+ * Returns a rewrite response for markdown requests matching configured
+ * routes, or `undefined` to pass through.
+ *
+ * @example
+ * // middleware.ts
+ * import { createMarkdownMiddleware } from 'next-md-negotiate';
+ *
+ * const markdownMiddleware = createMarkdownMiddleware({
+ *   routes: ['/products/[productId]', '/blog/[slug]'],
+ * });
+ *
+ * export function middleware(request: Request) {
+ *   return markdownMiddleware(request);
+ * }
+ */
+declare function createMarkdownMiddleware(options: NegotiateOptions): (request: Request) => Response | undefined;
+
+export { type ExtractParams, type MarkdownRewriteOptions, type MdVersionHandler, type NegotiateOptions, createMarkdownMiddleware, createMarkdownProxy, createMarkdownRewrites, createMdApiHandler, createMdHandler, createMdVersion };

package/dist/index.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Extracts parameter names from a Next.js-style route pattern.
+ *
+ * '/products/[productId]'        → { productId: string }
+ * '/blog/[slug]'                 → { slug: string }
+ * '/docs/[section]/[page]'       → { section: string; page: string }
+ * '/docs/[...slug]'              → { slug: string }
+ */
+type ExtractParams<T extends string> = T extends `${string}[...${infer Param}]${infer Rest}` ? {
+    [K in Param]: string;
+} & ExtractParams<Rest> : T extends `${string}[${infer Param}]${infer Rest}` ? {
+    [K in Param]: string;
+} & ExtractParams<Rest> : {};
+interface MdVersionHandler {
+    pattern: string;
+    handler: (params: Record<string, string>) => Promise<string>;
+}
+
+/**
+ * Defines a markdown version for a route.
+ *
+ * @example
+ * createMdVersion('/products/[productId]', async ({ productId }) => {
+ *   const product = await getProduct(productId);
+ *   return `# ${product.name}\n\n${product.description}`;
+ * });
+ */
+declare function createMdVersion<T extends string>(pattern: T, handler: (params: ExtractParams<T>) => Promise<string>): MdVersionHandler;
+
+/**
+ * Creates a Next.js route handler for the catch-all `/md-api/[...path]` route.
+ *
+ * @example
+ * // app/md-api/[...path]/route.ts
+ * import { createMdHandler } from 'next-md-negotiate';
+ * import registry from '@/md.config';
+ *
+ * export const GET = createMdHandler(registry);
+ */
+declare function createMdHandler(registry: MdVersionHandler[]): (req: Request, ctx: {
+    params: Promise<{
+        path: string[];
+    }>;
+}) => Promise<Response>;
+
+interface NextApiRequest {
+    query: Record<string, string | string[] | undefined>;
+}
+interface NextApiResponse {
+    status(code: number): NextApiResponse;
+    setHeader(name: string, value: string): NextApiResponse;
+    end(body?: string): void;
+}
+/**
+ * Creates a Pages Router API handler for `pages/api/md-api/[...path].ts`.
+ *
+ * @example
+ * // pages/api/md-api/[...path].ts
+ * import { createMdApiHandler } from 'next-md-negotiate';
+ * import registry from '@/md.config';
+ *
+ * export default createMdApiHandler(registry);
+ */
+declare function createMdApiHandler(registry: MdVersionHandler[]): (req: NextApiRequest, res: NextApiResponse) => Promise<void>;
+
+interface MarkdownRewriteOptions {
+    routes: string[];
+    /** Internal route prefix. Defaults to '/md-api'. */
+    internalPrefix?: string;
+}
+/**
+ * Generates Next.js rewrite rules that redirect markdown requests
+ * to the catch-all handler.
+ *
+ * Translates Next.js [param] syntax to :param for rewrite rules.
+ *
+ * @example
+ * // next.config.ts
+ * import { createMarkdownRewrites } from 'next-md-negotiate';
+ *
+ * export default {
+ *   async rewrites() {
+ *     return {
+ *       beforeFiles: createMarkdownRewrites({
+ *         routes: ['/products/[productId]', '/blog/[slug]'],
+ *       }),
+ *     };
+ *   },
+ * };
+ */
+declare function createMarkdownRewrites(options: MarkdownRewriteOptions): {
+    source: string;
+    has: {
+        type: "header";
+        key: string;
+        value: string;
+    }[];
+    destination: string;
+}[];
+
+interface NegotiateOptions {
+    routes: string[];
+    internalPrefix?: string;
+}
+
+/**
+ * Creates a proxy handler for Next.js 16+ `proxy.ts`.
+ *
+ * Returns a rewrite response for markdown requests matching
+ * configured routes, or `undefined` to pass through.
+ *
+ * @example
+ * // proxy.ts
+ * import { createMarkdownProxy } from 'next-md-negotiate';
+ *
+ * const markdownProxy = createMarkdownProxy({
+ *   routes: ['/products/[productId]', '/blog/[slug]'],
+ * });
+ *
+ * export function proxy(request: Request) {
+ *   return markdownProxy(request);
+ * }
+ */
+declare function createMarkdownProxy(options: NegotiateOptions): (request: Request) => Response | undefined;
+
+/**
+ * Creates a middleware handler for Next.js 14-15 `middleware.ts`.
+ *
+ * Returns a rewrite response for markdown requests matching configured
+ * routes, or `undefined` to pass through.
+ *
+ * @example
+ * // middleware.ts
+ * import { createMarkdownMiddleware } from 'next-md-negotiate';
+ *
+ * const markdownMiddleware = createMarkdownMiddleware({
+ *   routes: ['/products/[productId]', '/blog/[slug]'],
+ * });
+ *
+ * export function middleware(request: Request) {
+ *   return markdownMiddleware(request);
+ * }
+ */
+declare function createMarkdownMiddleware(options: NegotiateOptions): (request: Request) => Response | undefined;
+
+export { type ExtractParams, type MarkdownRewriteOptions, type MdVersionHandler, type NegotiateOptions, createMarkdownMiddleware, createMarkdownProxy, createMarkdownRewrites, createMdApiHandler, createMdHandler, createMdVersion };

package/dist/index.js

@@ -0,0 +1,175 @@
+// src/validatePattern.ts
+var VALID_PATTERN = /^(\/([a-zA-Z0-9_-]+|\[(\.\.\.)?[a-zA-Z_]+\]))+$|^\/$/;
+function validatePattern(pattern) {
+  if (!VALID_PATTERN.test(pattern)) {
+    throw new Error(
+      `Invalid route pattern: "${pattern}". Patterns must start with / and use [param] or [...param] for dynamic segments.`
+    );
+  }
+}
+
+// src/createMdVersion.ts
+function createMdVersion(pattern, handler) {
+  validatePattern(pattern);
+  return { pattern, handler };
+}
+
+// src/matchPath.ts
+var regexCache = /* @__PURE__ */ new Map();
+function compilePattern(pattern) {
+  const cached = regexCache.get(pattern);
+  if (cached) return cached;
+  const CATCHALL_TOKEN = "\0CATCHALL_";
+  const PARAM_TOKEN = "\0PARAM_";
+  let tokenized = pattern;
+  const catchAllNames = [];
+  const paramNames = [];
+  tokenized = tokenized.replace(/\[\.\.\.([a-zA-Z_]+)\]/g, (_, name) => {
+    catchAllNames.push(name);
+    return `${CATCHALL_TOKEN}${catchAllNames.length - 1}\0`;
+  });
+  tokenized = tokenized.replace(/\[([a-zA-Z_]+)\]/g, (_, name) => {
+    paramNames.push(name);
+    return `${PARAM_TOKEN}${paramNames.length - 1}\0`;
+  });
+  let regexStr = tokenized.replace(/[.*+?^${}()|\\]/g, "\\$&");
+  catchAllNames.forEach((name, i) => {
+    regexStr = regexStr.replace(`${CATCHALL_TOKEN}${i}\0`, `(?<${name}>.+)`);
+  });
+  paramNames.forEach((name, i) => {
+    regexStr = regexStr.replace(`${PARAM_TOKEN}${i}\0`, `(?<${name}>[^/]+)`);
+  });
+  const regex = new RegExp(`^${regexStr}$`);
+  regexCache.set(pattern, regex);
+  return regex;
+}
+function matchPath(pattern, path) {
+  const regex = compilePattern(pattern);
+  const match = path.match(regex);
+  if (!match) return null;
+  return match.groups ? { ...match.groups } : {};
+}
+
+// src/createMdHandler.ts
+function createMdHandler(registry) {
+  return async function GET(_req, { params }) {
+    const { path } = await params;
+    const incomingPath = "/" + path.join("/");
+    for (const route of registry) {
+      const match = matchPath(route.pattern, incomingPath);
+      if (match) {
+        try {
+          const markdown = await route.handler(match);
+          const headers = new Headers();
+          headers.set("Content-Type", "text/markdown; charset=utf-8");
+          return new Response(markdown, { status: 200, headers });
+        } catch (error) {
+          console.error("[next-md-negotiate] Handler error:", error);
+          return new Response("Internal Server Error", { status: 500 });
+        }
+      }
+    }
+    return new Response("Not Found", { status: 404 });
+  };
+}
+
+// src/createMdApiHandler.ts
+function createMdApiHandler(registry) {
+  return async function handler(req, res) {
+    const pathParam = req.query.path;
+    const pathSegments = Array.isArray(pathParam) ? pathParam : pathParam ? [pathParam] : [];
+    const incomingPath = "/" + pathSegments.join("/");
+    for (const route of registry) {
+      const match = matchPath(route.pattern, incomingPath);
+      if (match) {
+        try {
+          const markdown = await route.handler(match);
+          res.setHeader("Content-Type", "text/markdown; charset=utf-8");
+          res.status(200).end(markdown);
+          return;
+        } catch (error) {
+          console.error("[next-md-negotiate] Handler error:", error);
+          res.status(500).end("Internal Server Error");
+          return;
+        }
+      }
+    }
+    res.status(404).end("Not Found");
+  };
+}
+
+// src/createMarkdownRewrites.ts
+var MARKDOWN_ACCEPT_REGEX = ".*(text/markdown|application/markdown|text/x-markdown).*";
+function createMarkdownRewrites(options) {
+  const prefix = options.internalPrefix ?? "/md-api";
+  return options.routes.map((source) => {
+    validatePattern(source);
+    const rewritePath = source.replace(/\[\.\.\.([a-zA-Z_]+)\]/g, ":$1*").replace(/\[([a-zA-Z_]+)\]/g, ":$1");
+    return {
+      source: rewritePath,
+      has: [
+        {
+          type: "header",
+          key: "accept",
+          value: MARKDOWN_ACCEPT_REGEX
+        }
+      ],
+      destination: `${prefix}${rewritePath}`
+    };
+  });
+}
+
+// src/negotiateRequest.ts
+var MARKDOWN_TYPES = [
+  "text/markdown",
+  "application/markdown",
+  "text/x-markdown"
+];
+function negotiateRequest(request, options) {
+  const accept = request.headers.get("accept") ?? "";
+  const wantsMarkdown = MARKDOWN_TYPES.some((type) => accept.includes(type));
+  if (!wantsMarkdown) return null;
+  const url = new URL(request.url);
+  const pathname = url.pathname;
+  const prefix = options.internalPrefix ?? "/md-api";
+  for (const route of options.routes) {
+    if (matchPath(route, pathname)) {
+      return new URL(`${prefix}${pathname}`, url.origin);
+    }
+  }
+  return null;
+}
+
+// src/createRewriteHandler.ts
+function createRewriteHandler(options) {
+  for (const route of options.routes) {
+    validatePattern(route);
+  }
+  return (request) => {
+    const rewriteUrl = negotiateRequest(request, options);
+    if (!rewriteUrl) return void 0;
+    return new Response(null, {
+      headers: {
+        "x-middleware-rewrite": rewriteUrl.toString()
+      }
+    });
+  };
+}
+
+// src/createMarkdownProxy.ts
+function createMarkdownProxy(options) {
+  return createRewriteHandler(options);
+}
+
+// src/createMarkdownMiddleware.ts
+function createMarkdownMiddleware(options) {
+  return createRewriteHandler(options);
+}
+export {
+  createMarkdownMiddleware,
+  createMarkdownProxy,
+  createMarkdownRewrites,
+  createMdApiHandler,
+  createMdHandler,
+  createMdVersion
+};

package/package.json

@@ -1,8 +1,36 @@
 {
   "name": "next-md-negotiate",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Content negotiation for Next.js - serve Markdown to LLMs, HTML to browsers, from a single URL",
-  "main": "index.js",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "next-md-negotiate": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
   "keywords": [
     "nextjs",
     "markdown",
@@ -15,5 +43,13 @@
   "repository": {
     "type": "git",
     "url": "https://github.com/kasin-it/next-md-negotiate"
+  },
+  "peerDependencies": {
+    "next": ">=14.0.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^4.0.18"
   }
 }

package/index.js

@@ -1 +0,0 @@
-module.exports = {};