@mdsnai/sdk 0.1.0

package/dist/server/negotiate.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wantsHtml = wantsHtml;
+exports.wantsMarkdown = wantsMarkdown;
+exports.isNotAcceptableRequest = isNotAcceptableRequest;
+function parseAcceptHeader(acceptHeader) {
+    if (!acceptHeader || acceptHeader.trim().length === 0) {
+        return [];
+    }
+    return acceptHeader
+        .split(",")
+        .map((raw) => raw.trim())
+        .filter((raw) => raw.length > 0)
+        .map((part) => {
+        const [mediaTypeToken, ...parameterTokens] = part.split(";");
+        const mediaType = mediaTypeToken.trim().toLowerCase();
+        const qualityToken = parameterTokens.find((parameter) => parameter.trim().toLowerCase().startsWith("q="));
+        const parsedQuality = qualityToken ? Number.parseFloat(qualityToken.split("=")[1] ?? "") : 1;
+        const quality = Number.isFinite(parsedQuality) ? Math.min(Math.max(parsedQuality, 0), 1) : 1;
+        return {
+            mediaType,
+            quality,
+        };
+    })
+        .filter((entry) => entry.mediaType.length > 0);
+}
+function hasAcceptableMediaType(acceptHeader, matcher) {
+    return parseAcceptHeader(acceptHeader).some((entry) => entry.quality > 0 && matcher(entry.mediaType));
+}
+function wantsHtml(acceptHeader) {
+    return hasAcceptableMediaType(acceptHeader, (mediaType) => mediaType === "text/html" || mediaType === "application/xhtml+xml");
+}
+function wantsMarkdown(acceptHeader) {
+    return hasAcceptableMediaType(acceptHeader, (mediaType) => mediaType === "text/markdown");
+}
+function supportsAnyRepresentation(mediaType) {
+    if (mediaType === "*/*")
+        return true;
+    if (mediaType === "text/*")
+        return true;
+    if (mediaType === "text/html")
+        return true;
+    if (mediaType === "application/xhtml+xml")
+        return true;
+    if (mediaType === "text/markdown")
+        return true;
+    return false;
+}
+function isNotAcceptableRequest(acceptHeader) {
+    const entries = parseAcceptHeader(acceptHeader);
+    if (entries.length === 0) {
+        return false;
+    }
+    return !entries.some((entry) => entry.quality > 0 && supportsAnyRepresentation(entry.mediaType));
+}

package/dist/server/page-host.d.ts

@@ -0,0 +1,21 @@
+export interface HostedPageResponse {
+    status: number;
+    contentType: string;
+    body: string;
+}
+export interface RenderHostedPageOptions {
+    accept?: string;
+    routePath?: string;
+    siteTitle?: string;
+    siteDescription?: string;
+    siteBaseUrl?: string;
+    locales?: string[];
+    defaultLocale?: string;
+    markdown?: {
+        linkify?: boolean;
+        typographer?: boolean;
+    };
+    mapActionTarget?: (target: string) => string;
+    layoutTemplate?: string;
+}
+export declare function renderHostedPage(rawPage: string, options: RenderHostedPageOptions): HostedPageResponse;

package/dist/server/page-host.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderHostedPage = renderHostedPage;
+const page_definition_1 = require("../core/document/page-definition");
+const page_render_1 = require("../web/page-render");
+const page_html_1 = require("../web/page-html");
+const layout_1 = require("./layout");
+const page_links_1 = require("./page-links");
+const negotiate_1 = require("./negotiate");
+function renderHostedPage(rawPage, options) {
+    if ((0, negotiate_1.isNotAcceptableRequest)(options.accept)) {
+        return {
+            status: 406,
+            contentType: "text/plain; charset=utf-8",
+            body: "Not Acceptable",
+        };
+    }
+    if (!(0, negotiate_1.wantsHtml)(options.accept)) {
+        return {
+            status: 200,
+            contentType: "text/markdown; charset=utf-8",
+            body: rawPage,
+        };
+    }
+    const document = (0, page_definition_1.parsePageDefinition)(rawPage);
+    const routePath = options.routePath ?? "/";
+    const model = (0, page_render_1.createPageRenderModel)(document, {
+        mapActionTarget: options.mapActionTarget,
+        markdown: options.markdown,
+    });
+    const locale = (0, layout_1.resolveLocaleForRoutePath)(routePath, options.locales ?? ["en"], options.defaultLocale ?? "en");
+    const title = typeof document.frontmatter.title === "string" && document.frontmatter.title.trim().length > 0
+        ? document.frontmatter.title
+        : options.siteTitle;
+    const description = typeof document.frontmatter.description === "string" && document.frontmatter.description.trim().length > 0
+        ? document.frontmatter.description
+        : options.siteDescription ?? "";
+    const defaultLocale = options.defaultLocale ?? locale;
+    const body = options.layoutTemplate
+        ? (0, layout_1.applyLayoutTemplate)(options.layoutTemplate, {
+            title: title ?? "MDSN Page",
+            description,
+            content: (0, page_html_1.renderPageHtmlContent)(model),
+            locale,
+            defaultLocale,
+            pathname: routePath,
+            canonicalUrl: (0, page_links_1.resolveCanonicalUrl)(routePath, options.siteBaseUrl),
+            siteName: options.siteTitle,
+            markdownAlternateUrl: (0, page_links_1.resolveMarkdownAlternateUrl)(routePath, options.siteBaseUrl),
+            hreflangLinks: (0, page_links_1.resolveHreflangLinks)({
+                routePath,
+                locales: options.locales ?? ["en"],
+                defaultLocale,
+                siteBaseUrl: options.siteBaseUrl,
+            }),
+        })
+        : (0, page_html_1.renderPageHtmlDocument)(model, {
+            title,
+            lang: locale,
+        });
+    return {
+        status: 200,
+        contentType: "text/html; charset=utf-8",
+        body,
+    };
+}

package/dist/server/page-links.d.ts

@@ -0,0 +1,10 @@
+export declare function mapPageTargetToHttpPath(target: string): string;
+export declare function joinUrl(baseUrl: string, routePath: string): string;
+export declare function resolveCanonicalUrl(routePath: string, siteBaseUrl?: string): string | undefined;
+export declare function resolveMarkdownAlternateUrl(routePath: string, siteBaseUrl?: string): string;
+export declare function resolveHreflangLinks(options: {
+    routePath: string;
+    locales: string[];
+    defaultLocale: string;
+    siteBaseUrl?: string;
+}): string;

package/dist/server/page-links.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapPageTargetToHttpPath = mapPageTargetToHttpPath;
+exports.joinUrl = joinUrl;
+exports.resolveCanonicalUrl = resolveCanonicalUrl;
+exports.resolveMarkdownAlternateUrl = resolveMarkdownAlternateUrl;
+exports.resolveHreflangLinks = resolveHreflangLinks;
+const routes_1 = require("./routes");
+function mapPageTargetToHttpPath(target) {
+    if (/^https?:\/\//i.test(target)) {
+        return target;
+    }
+    const markdownRoutePath = (0, routes_1.markdownPathToRoutePath)(target);
+    if (markdownRoutePath) {
+        return markdownRoutePath;
+    }
+    return target;
+}
+function joinUrl(baseUrl, routePath) {
+    const normalizedBase = baseUrl.replace(/\/+$/, "");
+    const normalizedPath = routePath.startsWith("/") ? routePath : `/${routePath}`;
+    return `${normalizedBase}${normalizedPath}`;
+}
+function resolveCanonicalUrl(routePath, siteBaseUrl) {
+    if (!siteBaseUrl) {
+        return undefined;
+    }
+    return joinUrl(siteBaseUrl, routePath);
+}
+function resolveMarkdownAlternateUrl(routePath, siteBaseUrl) {
+    const markdownPath = (0, routes_1.routePathToMarkdownPath)(routePath);
+    if (!siteBaseUrl) {
+        return markdownPath;
+    }
+    return joinUrl(siteBaseUrl, markdownPath);
+}
+function normalizeRoutePath(routePath) {
+    if (!routePath || routePath === "/") {
+        return "/";
+    }
+    return routePath.replace(/\/+$/, "") || "/";
+}
+function resolveRouteSuffix(routePath, locales) {
+    const normalized = normalizeRoutePath(routePath);
+    if (normalized === "/")
+        return "/";
+    const segments = normalized.split("/").filter(Boolean);
+    const first = segments[0];
+    if (first && locales.includes(first)) {
+        const suffix = `/${segments.slice(1).join("/")}`;
+        return suffix === "/" ? "/" : suffix.replace(/\/+$/, "") || "/";
+    }
+    return normalized;
+}
+function resolveLocalizedRoutePath(locale, suffix, defaultLocale) {
+    if (locale === defaultLocale) {
+        return suffix;
+    }
+    if (suffix === "/") {
+        return `/${locale}`;
+    }
+    return `/${locale}${suffix}`;
+}
+function resolveHreflangLinks(options) {
+    const suffix = resolveRouteSuffix(options.routePath, options.locales);
+    const links = [];
+    const toHref = (routePath) => {
+        if (!options.siteBaseUrl) {
+            return routePath;
+        }
+        return joinUrl(options.siteBaseUrl, routePath);
+    };
+    for (const locale of options.locales) {
+        const href = toHref(resolveLocalizedRoutePath(locale, suffix, options.defaultLocale));
+        links.push(`<link rel="alternate" hreflang="${locale}" href="${href}" />`);
+    }
+    const defaultHref = toHref(resolveLocalizedRoutePath(options.defaultLocale, suffix, options.defaultLocale));
+    links.push(`<link rel="alternate" hreflang="x-default" href="${defaultHref}" />`);
+    return links.join("\n    ");
+}

package/dist/server/route-matcher.d.ts

@@ -0,0 +1,6 @@
+type RoutablePage = {
+    routePath: string;
+};
+export declare function sortRoutedPagesForMatching<T extends RoutablePage>(routedPages: T[]): T[];
+export declare function resolveRoutedPageForPath<T extends RoutablePage>(requestPath: string, routedPages: T[]): T | null;
+export {};

package/dist/server/route-matcher.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortRoutedPagesForMatching = sortRoutedPagesForMatching;
+exports.resolveRoutedPageForPath = resolveRoutedPageForPath;
+function normalizeRoutePath(pathname) {
+    if (!pathname)
+        return "/";
+    if (pathname === "/")
+        return pathname;
+    return pathname.replace(/\/+$/, "") || "/";
+}
+function isDynamicRouteSegment(segment) {
+    return /^\[[^\]/]+\]$/.test(segment);
+}
+function compareRouteSpecificity(left, right) {
+    const leftSegments = normalizeRoutePath(left.routePath).split("/").filter(Boolean);
+    const rightSegments = normalizeRoutePath(right.routePath).split("/").filter(Boolean);
+    const maxLength = Math.max(leftSegments.length, rightSegments.length);
+    for (let index = 0; index < maxLength; index += 1) {
+        const leftSegment = leftSegments[index];
+        const rightSegment = rightSegments[index];
+        const leftWeight = leftSegment
+            ? (isDynamicRouteSegment(leftSegment) ? 1 : 2)
+            : 0;
+        const rightWeight = rightSegment
+            ? (isDynamicRouteSegment(rightSegment) ? 1 : 2)
+            : 0;
+        if (leftWeight !== rightWeight) {
+            return rightWeight - leftWeight;
+        }
+    }
+    if (leftSegments.length !== rightSegments.length) {
+        return rightSegments.length - leftSegments.length;
+    }
+    return left.routePath.localeCompare(right.routePath);
+}
+function routePathMatchesRequestPath(routePath, requestPath) {
+    const normalizedRoutePath = normalizeRoutePath(routePath);
+    const normalizedRequestPath = normalizeRoutePath(requestPath);
+    if (normalizedRoutePath === normalizedRequestPath) {
+        return true;
+    }
+    if (!normalizedRoutePath.includes("[")) {
+        return false;
+    }
+    const routeSegments = normalizedRoutePath.split("/").filter(Boolean);
+    const requestSegments = normalizedRequestPath.split("/").filter(Boolean);
+    if (routeSegments.length !== requestSegments.length) {
+        return false;
+    }
+    for (let index = 0; index < routeSegments.length; index += 1) {
+        const routeSegment = routeSegments[index];
+        const requestSegment = requestSegments[index];
+        if (isDynamicRouteSegment(routeSegment)) {
+            continue;
+        }
+        if (routeSegment !== requestSegment) {
+            return false;
+        }
+    }
+    return true;
+}
+function sortRoutedPagesForMatching(routedPages) {
+    return [...routedPages].sort(compareRouteSpecificity);
+}
+function resolveRoutedPageForPath(requestPath, routedPages) {
+    for (const page of routedPages) {
+        if (routePathMatchesRequestPath(page.routePath, requestPath)) {
+            return page;
+        }
+    }
+    return null;
+}

package/dist/server/routes.d.ts

@@ -0,0 +1,6 @@
+export declare function pagePathToRoutePath(filePath: string, pagesDir: string): string;
+export declare function routePathToExpressPath(routePath: string): string;
+export declare function routePathToMarkdownPath(routePath: string): string;
+export declare function markdownPathToRoutePath(pathname: string): string | null;
+export declare function extractRouteParamNames(routePath: string): string[];
+export declare function defaultLocaleRouteToFallbackPath(routePath: string, defaultLocale: string): string | null;

package/dist/server/routes.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pagePathToRoutePath = pagePathToRoutePath;
+exports.routePathToExpressPath = routePathToExpressPath;
+exports.routePathToMarkdownPath = routePathToMarkdownPath;
+exports.markdownPathToRoutePath = markdownPathToRoutePath;
+exports.extractRouteParamNames = extractRouteParamNames;
+exports.defaultLocaleRouteToFallbackPath = defaultLocaleRouteToFallbackPath;
+function normalizeSegments(relativePath) {
+    return relativePath.split("/").filter(Boolean);
+}
+function normalizeRoutePath(routePath) {
+    if (!routePath || routePath === "/") {
+        return "/";
+    }
+    return routePath.startsWith("/")
+        ? (routePath.replace(/\/+$/, "") || "/")
+        : (`/${routePath}`.replace(/\/+$/, "") || "/");
+}
+function pagePathToRoutePath(filePath, pagesDir) {
+    const normalizedFilePath = filePath.replace(/\\/g, "/");
+    const normalizedPagesDir = pagesDir.replace(/\\/g, "/").replace(/\/+$/, "");
+    const withPrefix = `${normalizedPagesDir}/`;
+    const relativePath = normalizedFilePath.startsWith(withPrefix)
+        ? normalizedFilePath.slice(withPrefix.length)
+        : normalizedFilePath;
+    const withoutExtension = relativePath.replace(/\.md$/, "");
+    const segments = normalizeSegments(withoutExtension);
+    if (segments[segments.length - 1] === "index") {
+        segments.pop();
+    }
+    if (segments.length === 0) {
+        return "/";
+    }
+    return `/${segments.join("/")}`;
+}
+function routePathToExpressPath(routePath) {
+    return routePath.replace(/\[([^\]]+)\]/g, ":$1");
+}
+function routePathToMarkdownPath(routePath) {
+    const normalized = normalizeRoutePath(routePath);
+    if (normalized === "/") {
+        return "/index.md";
+    }
+    return `${normalized}.md`;
+}
+function markdownPathToRoutePath(pathname) {
+    if (!pathname || !pathname.toLowerCase().endsWith(".md")) {
+        return null;
+    }
+    const normalized = normalizeRoutePath(pathname);
+    if (normalized === "/index.md") {
+        return "/";
+    }
+    const stripped = normalized.slice(0, -3);
+    if (stripped.endsWith("/index")) {
+        return stripped.slice(0, -6) || "/";
+    }
+    return stripped.length > 0 ? stripped : "/";
+}
+function extractRouteParamNames(routePath) {
+    return Array.from(routePath.matchAll(/\[([^\]]+)\]/g), (match) => match[1]);
+}
+function defaultLocaleRouteToFallbackPath(routePath, defaultLocale) {
+    const localePrefix = `/${defaultLocale}`;
+    if (routePath === localePrefix) {
+        return "/";
+    }
+    if (routePath.startsWith(`${localePrefix}/`)) {
+        return routePath.slice(localePrefix.length);
+    }
+    return null;
+}

package/dist/server/server.d.ts

@@ -0,0 +1,27 @@
+import type { Express } from "express";
+import { type CreateFrameworkAppOptions } from "../framework/create-framework-app";
+import { type MdsnConfig } from "./config";
+export type CreateFrameworkAppFn = (options: CreateFrameworkAppOptions) => Express;
+export type ListenFn = (options: {
+    app: Express;
+    port: number;
+    log: (message: string) => void;
+}) => Promise<void>;
+export type OpenBrowserFn = (url: string) => Promise<void> | void;
+export declare function loadUserConfig(rootDir: string): Promise<MdsnConfig>;
+export declare function loadBuiltConfig(distDir: string): MdsnConfig | null;
+export declare function listenOnPort(options: {
+    app: Express;
+    port: number;
+    log: (message: string) => void;
+}): Promise<void>;
+export declare function openBrowser(url: string): void;
+export declare function startFrameworkServer(options?: {
+    cwd?: string;
+    port?: number;
+    mode?: "dev" | "start";
+    createApp?: CreateFrameworkAppFn;
+    listen?: ListenFn;
+    openBrowser?: OpenBrowserFn;
+    log?: (message: string) => void;
+}): Promise<void>;

package/dist/server/server.js

@@ -0,0 +1,152 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadUserConfig = loadUserConfig;
+exports.loadBuiltConfig = loadBuiltConfig;
+exports.listenOnPort = listenOnPort;
+exports.openBrowser = openBrowser;
+exports.startFrameworkServer = startFrameworkServer;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const create_framework_app_1 = require("../framework/create-framework-app");
+const config_1 = require("./config");
+const dev_1 = require("./dev");
+const module_loader_1 = require("./module-loader");
+const USER_CONFIG_CANDIDATES = [
+    "mdsn.config.cjs",
+    "mdsn.config.js",
+    "mdsn.config.json",
+    "mdsn.config.ts",
+    "mdsn.config.mts",
+    "mdsn.config.cts",
+];
+function formatConfigLoadError(configPath, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const extension = node_path_1.default.extname(configPath).toLowerCase();
+    const isTypeScriptConfig = extension === ".ts" || extension === ".mts" || extension === ".cts";
+    if (isTypeScriptConfig) {
+        return new Error(`Failed to load ${node_path_1.default.basename(configPath)}: ${message}. `
+            + "If you are using the published mdsn CLI binary, prefer mdsn.config.cjs for portable runtime loading.");
+    }
+    return new Error(`Failed to load ${node_path_1.default.basename(configPath)}: ${message}`);
+}
+async function loadConfigFromFile(configPath) {
+    const extension = node_path_1.default.extname(configPath).toLowerCase();
+    if (extension === ".json") {
+        return JSON.parse((0, node_fs_1.readFileSync)(configPath, "utf8"));
+    }
+    try {
+        const loadedModule = await (0, module_loader_1.importModuleFromFile)(configPath);
+        return (loadedModule.default ?? loadedModule);
+    }
+    catch (error) {
+        throw formatConfigLoadError(configPath, error);
+    }
+}
+async function loadUserConfig(rootDir) {
+    const availableConfigPaths = USER_CONFIG_CANDIDATES
+        .map((name) => node_path_1.default.join(rootDir, name))
+        .filter((candidatePath) => (0, node_fs_1.existsSync)(candidatePath));
+    if (availableConfigPaths.length === 0) {
+        return {};
+    }
+    const errors = [];
+    for (const configPath of availableConfigPaths) {
+        try {
+            return await loadConfigFromFile(configPath);
+        }
+        catch (error) {
+            errors.push(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    if (errors.length === 1) {
+        throw errors[0];
+    }
+    const details = errors.map((error) => `- ${error.message}`).join("\n");
+    throw new Error(`Failed to load user config from ${rootDir}:\n${details}`);
+}
+function loadBuiltConfig(distDir) {
+    const configPath = node_path_1.default.join(distDir, "mdsn.config.json");
+    if (!(0, node_fs_1.existsSync)(configPath)) {
+        return null;
+    }
+    return JSON.parse((0, node_fs_1.readFileSync)(configPath, "utf8"));
+}
+async function listenOnPort(options) {
+    const { app, port, log } = options;
+    await new Promise((resolve, reject) => {
+        const server = app.listen(port, () => {
+            log(`MDSN framework server listening on http://localhost:${port}`);
+            resolve();
+        });
+        server.on("error", reject);
+    });
+}
+function openBrowser(url) {
+    const command = process.platform === "darwin"
+        ? { file: "open", args: [url] }
+        : process.platform === "win32"
+            ? { file: "cmd", args: ["/c", "start", "", url] }
+            : { file: "xdg-open", args: [url] };
+    const child = (0, node_child_process_1.spawn)(command.file, command.args, {
+        detached: true,
+        stdio: "ignore",
+    });
+    child.unref();
+}
+async function startFrameworkServer(options = {}) {
+    const cwd = node_path_1.default.resolve(options.cwd ?? process.cwd());
+    const distDir = node_path_1.default.join(cwd, "dist");
+    const shouldUseDist = options.mode === "start";
+    const builtConfig = shouldUseDist ? loadBuiltConfig(distDir) : null;
+    const rootDir = builtConfig ? distDir : cwd;
+    const config = builtConfig ?? await loadUserConfig(rootDir);
+    const resolvedConfig = (0, config_1.resolveConfig)(config);
+    const devState = options.mode === "dev" ? (0, dev_1.createDevState)() : undefined;
+    const app = (options.createApp ?? create_framework_app_1.createFrameworkApp)({
+        rootDir,
+        mode: options.mode,
+        config,
+        devState,
+    });
+    if (devState) {
+        for (const directoryName of [
+            resolvedConfig.dirs.pages,
+            resolvedConfig.dirs.server,
+            resolvedConfig.dirs.public,
+            resolvedConfig.dirs.layouts,
+        ]) {
+            const targetDir = node_path_1.default.join(rootDir, directoryName);
+            if (!(0, node_fs_1.existsSync)(targetDir))
+                continue;
+            try {
+                (0, node_fs_1.watch)(targetDir, { recursive: true }, (_eventType, fileName) => {
+                    const relativeName = typeof fileName === "string" && fileName
+                        ? node_path_1.default.join(directoryName, fileName).split(node_path_1.default.sep).join("/")
+                        : directoryName;
+                    devState.bumpVersion(relativeName);
+                });
+            }
+            catch {
+                // Ignore watcher setup failures for now; the dev server remains usable without auto-reload.
+            }
+        }
+    }
+    const port = options.port ?? resolvedConfig.server.port;
+    await (options.listen ?? listenOnPort)({
+        app,
+        port,
+        log: options.log ?? console.log,
+    });
+    if (options.mode === "dev" && resolvedConfig.dev.openBrowser) {
+        try {
+            await (options.openBrowser ?? openBrowser)(`http://localhost:${port}`);
+        }
+        catch {
+            // Keep the dev server usable even if the opener is unavailable.
+        }
+    }
+}

package/dist/server/site.d.ts

@@ -0,0 +1,11 @@
+import { type MdsnConfig } from "./config";
+export type FrameworkSitePaths = {
+    rootDir: string;
+    pagesDir: string;
+    serverDir: string;
+    publicDir: string;
+    layoutsDir: string;
+};
+export declare function resolveSitePaths(rootDir: string, config: MdsnConfig): FrameworkSitePaths;
+export declare function findPageFiles(pagesDir: string): string[];
+export declare function findActionFiles(serverDir: string): string[];

package/dist/server/site.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSitePaths = resolveSitePaths;
+exports.findPageFiles = findPageFiles;
+exports.findActionFiles = findActionFiles;
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = require("node:fs");
+const config_1 = require("./config");
+function resolveSitePaths(rootDir, config) {
+    const resolved = (0, config_1.resolveConfig)(config);
+    return {
+        rootDir,
+        pagesDir: node_path_1.default.join(rootDir, resolved.dirs.pages),
+        serverDir: node_path_1.default.join(rootDir, resolved.dirs.server),
+        publicDir: node_path_1.default.join(rootDir, resolved.dirs.public),
+        layoutsDir: node_path_1.default.join(rootDir, resolved.dirs.layouts),
+    };
+}
+function walkFiles(rootDir) {
+    try {
+        const entries = (0, node_fs_1.readdirSync)(rootDir, { withFileTypes: true });
+        const files = [];
+        for (const entry of entries) {
+            const absolutePath = node_path_1.default.join(rootDir, entry.name);
+            if (entry.isDirectory()) {
+                files.push(...walkFiles(absolutePath));
+                continue;
+            }
+            if (entry.isFile()) {
+                files.push(absolutePath);
+            }
+        }
+        return files;
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    }
+}
+function hasIgnoredPrivateSegment(rootDir, filePath) {
+    const relativeSegments = node_path_1.default.relative(rootDir, filePath).split(node_path_1.default.sep).filter(Boolean);
+    return relativeSegments.some((segment) => segment.startsWith("_") || segment === "lib");
+}
+function findPageFiles(pagesDir) {
+    return walkFiles(pagesDir)
+        .filter((filePath) => filePath.endsWith(".md"))
+        .sort();
+}
+function findActionFiles(serverDir) {
+    return walkFiles(serverDir)
+        .filter((filePath) => /\.(js|mjs|cjs)$/.test(filePath))
+        .filter((filePath) => !hasIgnoredPrivateSegment(serverDir, filePath))
+        .sort();
+}

package/dist/server/targets.d.ts

@@ -0,0 +1,7 @@
+export type FrameworkTarget = {
+    kind: "action";
+    target: string;
+    actionPath: string;
+};
+export declare function parseFrameworkTarget(target: string): FrameworkTarget | null;
+export declare function isActionTarget(target: string): boolean;