@mdsnai/sdk 0.1.0

package/dist/framework/site-app.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadActionHandlers = loadActionHandlers;
+exports.createSiteApp = createSiteApp;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const hosted_app_1 = require("./hosted-app");
+const frontmatter_1 = require("../core/document/frontmatter");
+const config_1 = require("../server/config");
+const module_loader_1 = require("../server/module-loader");
+const site_1 = require("../server/site");
+const routes_1 = require("../server/routes");
+function walkMarkdownFiles(directory) {
+    const files = [];
+    for (const entry of (0, node_fs_1.readdirSync)(directory, { withFileTypes: true })) {
+        const absolutePath = node_path_1.default.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...walkMarkdownFiles(absolutePath));
+            continue;
+        }
+        if (entry.isFile() && absolutePath.endsWith(".md")) {
+            files.push(absolutePath);
+        }
+    }
+    return files;
+}
+function actionFileToId(filePath, serverDir) {
+    return node_path_1.default.relative(serverDir, filePath).split(node_path_1.default.sep).join("/").replace(/\.[^.]+$/u, "");
+}
+function resolveActionLocation(actionId, actionFilesById) {
+    const directFile = actionFilesById.get(actionId);
+    if (directFile) {
+        return { filePath: directFile };
+    }
+    const segments = actionId.split("/").filter(Boolean);
+    const exportName = segments.pop();
+    if (!exportName) {
+        return null;
+    }
+    const actionsFileId = segments.length > 0 ? `${segments.join("/")}/actions` : "actions";
+    const actionsFile = actionFilesById.get(actionsFileId);
+    if (!actionsFile) {
+        return null;
+    }
+    return {
+        filePath: actionsFile,
+        exportName,
+    };
+}
+function resolveLayoutTemplate(layoutsDir, rawPage) {
+    const { frontmatter } = (0, frontmatter_1.parseFrontmatter)(rawPage);
+    const value = frontmatter.layout;
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const normalized = value.trim();
+    if (!normalized || normalized.toLowerCase() === "none") {
+        return undefined;
+    }
+    if (!/^[a-zA-Z0-9/_-]+$/u.test(normalized)) {
+        return undefined;
+    }
+    const root = node_path_1.default.resolve(layoutsDir);
+    const candidate = node_path_1.default.resolve(root, `${normalized}.html`);
+    const relative = node_path_1.default.relative(root, candidate);
+    if (relative.startsWith("..") || node_path_1.default.isAbsolute(relative) || !(0, node_fs_1.existsSync)(candidate)) {
+        return undefined;
+    }
+    return (0, node_fs_1.readFileSync)(candidate, "utf8");
+}
+function loadActionHandlers(serverDir) {
+    const actionFiles = (0, site_1.findActionFiles)(serverDir);
+    const actionFilesById = new Map(actionFiles.map((filePath) => [actionFileToId(filePath, serverDir), filePath]));
+    const handlers = new Map();
+    return new Proxy({}, {
+        get(_target, property) {
+            if (typeof property !== "string") {
+                return undefined;
+            }
+            const cached = handlers.get(property);
+            if (cached) {
+                return cached;
+            }
+            const resolved = resolveActionLocation(property, actionFilesById);
+            if (!resolved) {
+                return undefined;
+            }
+            const handler = async (ctx) => {
+                const mod = await (0, module_loader_1.importModuleFromFile)(resolved.filePath);
+                const actionModule = (resolved.exportName
+                    ? mod.default?.[resolved.exportName]
+                        ?? mod.actions?.[resolved.exportName]
+                        ?? mod[resolved.exportName]
+                    : mod.default?.action
+                        ?? mod.default
+                        ?? mod.action
+                        ?? mod);
+                if (typeof actionModule?.run !== "function") {
+                    throw new Error(resolved.exportName
+                        ? `Action module must export ${resolved.exportName} from ${resolved.filePath}`
+                        : `Action module must export a run() function: ${resolved.filePath}`);
+                }
+                return actionModule.run(ctx);
+            };
+            handlers.set(property, handler);
+            return handler;
+        },
+    });
+}
+function createSiteApp(options) {
+    const resolvedConfig = (0, config_1.resolveConfig)(options.config ?? {});
+    const pagesDir = node_path_1.default.join(options.rootDir, resolvedConfig.dirs.pages);
+    const serverDir = node_path_1.default.join(options.rootDir, resolvedConfig.dirs.server);
+    const publicDir = node_path_1.default.join(options.rootDir, resolvedConfig.dirs.public);
+    const layoutsDir = node_path_1.default.join(options.rootDir, resolvedConfig.dirs.layouts);
+    const pageFiles = walkMarkdownFiles(pagesDir);
+    const pages = {};
+    const actions = options.actions ?? loadActionHandlers(serverDir);
+    for (const filePath of pageFiles) {
+        const routePath = (0, routes_1.pagePathToRoutePath)(filePath, pagesDir);
+        const pageSource = (0, node_fs_1.readFileSync)(filePath, "utf8");
+        pages[routePath] = pageSource;
+        const fallbackRoutePath = (0, routes_1.defaultLocaleRouteToFallbackPath)(routePath, resolvedConfig.i18n.defaultLocale);
+        if (fallbackRoutePath && !pages[fallbackRoutePath]) {
+            pages[fallbackRoutePath] = pageSource;
+        }
+    }
+    const app = (0, hosted_app_1.createHostedApp)({
+        pages,
+        actions,
+        publicDir,
+        render: {
+            siteTitle: resolvedConfig.site.title,
+            siteDescription: resolvedConfig.site.description,
+            siteBaseUrl: resolvedConfig.site.baseUrl,
+            locales: resolvedConfig.i18n.locales,
+            defaultLocale: resolvedConfig.i18n.defaultLocale,
+            markdown: resolvedConfig.markdown,
+            resolveLayoutTemplate: (_routePath, rawPage) => resolveLayoutTemplate(layoutsDir, rawPage),
+        },
+    });
+    return app;
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { parsePageDefinition } from "./core";
+export type { BlockAnchorDefinition, BlockDefinition, DocumentDefinition, FrontmatterData, InputDefinition, InputType, ReadDefinition, RedirectDefinition, SchemaDefinition, WriteDefinition, } from "./core";
+export { createRenderModel, getClientRuntimeScript, parseFragment, parseMarkdown, parsePage, renderDefaultHtmlDocument, renderPageHtml, } from "./web";
+export type { CreateRenderModelOptions, ParsedFragment, ParsedPage, RenderModel, } from "./web";
+export { createFrameworkApp, defineConfig, } from "./framework";
+export type { CreateFrameworkAppOptions, MdsnConfig, } from "./framework";
+export { defineAction } from "./server";
+export type { ActionContext, ActionDefinition, ActionResult, } from "./server";

package/dist/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineAction = exports.defineConfig = exports.createFrameworkApp = exports.renderPageHtml = exports.renderDefaultHtmlDocument = exports.parsePage = exports.parseMarkdown = exports.parseFragment = exports.getClientRuntimeScript = exports.createRenderModel = exports.parsePageDefinition = void 0;
+var core_1 = require("./core");
+Object.defineProperty(exports, "parsePageDefinition", { enumerable: true, get: function () { return core_1.parsePageDefinition; } });
+var web_1 = require("./web");
+Object.defineProperty(exports, "createRenderModel", { enumerable: true, get: function () { return web_1.createRenderModel; } });
+Object.defineProperty(exports, "getClientRuntimeScript", { enumerable: true, get: function () { return web_1.getClientRuntimeScript; } });
+Object.defineProperty(exports, "parseFragment", { enumerable: true, get: function () { return web_1.parseFragment; } });
+Object.defineProperty(exports, "parseMarkdown", { enumerable: true, get: function () { return web_1.parseMarkdown; } });
+Object.defineProperty(exports, "parsePage", { enumerable: true, get: function () { return web_1.parsePage; } });
+Object.defineProperty(exports, "renderDefaultHtmlDocument", { enumerable: true, get: function () { return web_1.renderDefaultHtmlDocument; } });
+Object.defineProperty(exports, "renderPageHtml", { enumerable: true, get: function () { return web_1.renderPageHtml; } });
+var framework_1 = require("./framework");
+Object.defineProperty(exports, "createFrameworkApp", { enumerable: true, get: function () { return framework_1.createFrameworkApp; } });
+Object.defineProperty(exports, "defineConfig", { enumerable: true, get: function () { return framework_1.defineConfig; } });
+var server_1 = require("./server");
+Object.defineProperty(exports, "defineAction", { enumerable: true, get: function () { return server_1.defineAction; } });

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

@@ -0,0 +1,3 @@
+import { type ActionResult } from "../core/action";
+export type ActionHandler<Context = unknown> = (ctx: Context) => Promise<unknown> | unknown;
+export declare function executeActionHandler<Context>(handler: ActionHandler<Context>, ctx?: Context): Promise<ActionResult>;

package/dist/server/action-host.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeActionHandler = executeActionHandler;
+const action_1 = require("../core/action");
+async function executeActionHandler(handler, ctx) {
+    const result = await handler(ctx);
+    return (0, action_1.normalizeActionResult)(result);
+}

package/dist/server/action-runtime.d.ts

@@ -0,0 +1,8 @@
+import type express from "express";
+import { type ActionContext, type ActionRegistry } from "./action";
+export declare function summarizeActionInputs(inputs: Record<string, unknown>): string;
+export declare function createActionFilesSignature(actionFiles: string[], actionsDir: string): string;
+export declare function loadActionRegistry(actionFiles: string[], actionsDir: string, options?: {
+    fresh?: boolean;
+}): Promise<ActionRegistry>;
+export declare function createActionContext(req: express.Request, siteTitle?: string, siteBaseUrl?: string): ActionContext;

package/dist/server/action-runtime.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarizeActionInputs = summarizeActionInputs;
+exports.createActionFilesSignature = createActionFilesSignature;
+exports.loadActionRegistry = loadActionRegistry;
+exports.createActionContext = createActionContext;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const action_1 = require("./action");
+const module_loader_1 = require("./module-loader");
+function toPosixRelativePath(baseDir, filePath) {
+    return node_path_1.default.relative(baseDir, filePath).split(node_path_1.default.sep).join("/");
+}
+function summarizeActionInputs(inputs) {
+    try {
+        const serialized = JSON.stringify(inputs);
+        if (!serialized) {
+            return "{}";
+        }
+        return serialized.length > 240 ? `${serialized.slice(0, 237)}...` : serialized;
+    }
+    catch {
+        return "[unserializable inputs]";
+    }
+}
+function createActionFilesSignature(actionFiles, actionsDir) {
+    return actionFiles.map((filePath) => {
+        const relativePath = toPosixRelativePath(actionsDir, filePath);
+        try {
+            const stats = (0, node_fs_1.statSync)(filePath);
+            return `${relativePath}:${stats.mtimeMs}`;
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return `${relativePath}:missing`;
+            }
+            throw error;
+        }
+    }).join("|");
+}
+async function loadActionRegistry(actionFiles, actionsDir, options = {}) {
+    const entries = [];
+    for (const filePath of actionFiles) {
+        const actionModule = await (0, module_loader_1.importModuleFromFile)(filePath, { fresh: options.fresh });
+        const actionEntries = (0, action_1.resolveActionModuleEntries)(actionModule, filePath);
+        const relativePath = toPosixRelativePath(actionsDir, filePath);
+        for (const entry of actionEntries) {
+            entries.push({
+                id: (0, action_1.actionExportNameToActionId)(relativePath, "", entry.exportName),
+                action: entry.action,
+            });
+        }
+    }
+    return (0, action_1.createActionRegistry)(entries);
+}
+function createActionContext(req, siteTitle, siteBaseUrl) {
+    const body = (req.body ?? {});
+    return {
+        inputs: body.inputs ?? {},
+        params: Object.fromEntries(Object.entries(req.params).map(([key, value]) => [key, String(value)])),
+        query: new URLSearchParams(Object.entries(req.query).flatMap(([key, value]) => {
+            if (value === undefined)
+                return [];
+            if (Array.isArray(value)) {
+                return value.map((item) => [key, String(item)]);
+            }
+            return [[key, String(value)]];
+        })),
+        pathname: typeof body.pathname === "string" ? body.pathname : req.path,
+        request: req,
+        cookies: {},
+        env: process.env,
+        site: {
+            title: siteTitle,
+            baseUrl: siteBaseUrl,
+        },
+    };
+}

package/dist/server/action.d.ts

@@ -0,0 +1,41 @@
+import type { ActionResult as HostedActionResult } from "../core/action";
+export type ActionContext = {
+    inputs: Record<string, unknown>;
+    params: Record<string, string>;
+    query: URLSearchParams;
+    pathname: string;
+    request: unknown;
+    cookies: unknown;
+    env: Record<string, string | undefined>;
+    site: {
+        title?: string;
+        baseUrl?: string;
+    };
+};
+export type ActionFailure = {
+    ok: false;
+    errorCode: string;
+    message?: string;
+    fieldErrors?: Record<string, string>;
+};
+export type ActionResult = HostedActionResult | ActionFailure;
+export type ActionReturnValue = string | ActionResult;
+export type ActionDefinition = {
+    name?: string;
+    auth?: boolean;
+    run: (ctx: ActionContext) => Promise<ActionReturnValue> | ActionReturnValue;
+};
+export type ActionDefinitionMap = Record<string, ActionDefinition>;
+export type RegisteredAction = {
+    id: string;
+    action: ActionDefinition;
+    exportName?: string;
+};
+export type ActionRegistry = Map<string, ActionDefinition>;
+export declare function defineAction(action: ActionDefinition): ActionDefinition;
+export declare function defineActions(actions: ActionDefinitionMap): ActionDefinitionMap;
+export declare function actionFilePathToActionId(filePath: string, actionsDir: string): string;
+export declare function actionExportNameToActionId(filePath: string, actionsDir: string, exportName?: string): string;
+export declare function resolveActionModuleEntries(actionModule: Record<string, unknown>, filePath: string): RegisteredAction[];
+export declare function createActionRegistry(entries: RegisteredAction[]): ActionRegistry;
+export declare function resolveActionById(registry: ActionRegistry, id: string): ActionDefinition | undefined;

package/dist/server/action.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineAction = defineAction;
+exports.defineActions = defineActions;
+exports.actionFilePathToActionId = actionFilePathToActionId;
+exports.actionExportNameToActionId = actionExportNameToActionId;
+exports.resolveActionModuleEntries = resolveActionModuleEntries;
+exports.createActionRegistry = createActionRegistry;
+exports.resolveActionById = resolveActionById;
+const node_path_1 = __importDefault(require("node:path"));
+function defineAction(action) {
+    return action;
+}
+function defineActions(actions) {
+    return actions;
+}
+function actionFilePathToActionId(filePath, actionsDir) {
+    const normalizedPath = filePath.split(node_path_1.default.sep).join("/");
+    const normalizedActionsDir = actionsDir.split(node_path_1.default.sep).join("/");
+    const prefix = normalizedActionsDir.endsWith("/") ? normalizedActionsDir : `${normalizedActionsDir}/`;
+    const withoutPrefix = normalizedPath.startsWith(prefix) ? normalizedPath.slice(prefix.length) : normalizedPath;
+    return withoutPrefix.replace(/\.[^.]+$/, "");
+}
+function normalizeMultiActionBaseId(actionId) {
+    if (actionId === "actions") {
+        return "";
+    }
+    if (actionId.endsWith("/actions")) {
+        return actionId.slice(0, -"/actions".length);
+    }
+    return actionId;
+}
+function actionExportNameToActionId(filePath, actionsDir, exportName) {
+    const fileActionId = actionFilePathToActionId(filePath, actionsDir);
+    if (!exportName) {
+        return fileActionId;
+    }
+    const baseId = normalizeMultiActionBaseId(fileActionId);
+    return baseId ? `${baseId}/${exportName}` : exportName;
+}
+function isActionDefinition(value) {
+    return !!value && typeof value === "object" && typeof value.run === "function";
+}
+function actionDefinitionEntriesFromMap(candidate) {
+    if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) {
+        return null;
+    }
+    const entries = Object.entries(candidate)
+        .filter(([key]) => !["default", "action", "actions", "__esModule"].includes(key));
+    if (entries.length === 0 || !entries.every(([, value]) => isActionDefinition(value))) {
+        return null;
+    }
+    return entries.map(([exportName, action]) => ({
+        id: exportName,
+        exportName,
+        action: action,
+    }));
+}
+function resolveActionModuleEntries(actionModule, filePath) {
+    const singleCandidates = [
+        actionModule.default,
+        actionModule.action,
+        actionModule,
+    ];
+    for (const candidate of singleCandidates) {
+        if (isActionDefinition(candidate)) {
+            return [{ id: "", action: candidate }];
+        }
+        if (candidate
+            && typeof candidate === "object"
+            && isActionDefinition(candidate.action)) {
+            return [{ id: "", action: candidate.action }];
+        }
+    }
+    const mapCandidates = [
+        actionModule.default?.actions,
+        actionModule.actions,
+        actionModule.default,
+        actionModule,
+    ];
+    for (const candidate of mapCandidates) {
+        const entries = actionDefinitionEntriesFromMap(candidate);
+        if (entries) {
+            return entries;
+        }
+    }
+    throw new Error(`Expected action module at ${filePath} to export defineAction() or defineActions() results`);
+}
+function createActionRegistry(entries) {
+    return new Map(entries.map((entry) => [entry.id, entry.action]));
+}
+function resolveActionById(registry, id) {
+    return registry.get(id);
+}

package/dist/server/build.d.ts

@@ -0,0 +1,10 @@
+import { type MdsnConfig } from "./config";
+export type BuildOutput = {
+    outDir: string;
+    pagesManifestPath: string;
+    actionsManifestPath: string;
+};
+export declare function buildFrameworkSite(options: {
+    rootDir: string;
+    config?: MdsnConfig;
+}): Promise<BuildOutput>;

package/dist/server/build.js

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFrameworkSite = buildFrameworkSite;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const action_1 = require("./action");
+const config_1 = require("./config");
+const page_definition_1 = require("../core/document/page-definition");
+const routes_1 = require("./routes");
+const site_1 = require("./site");
+function copyDirectoryContents(sourceDir, destinationDir) {
+    const entries = (0, node_fs_1.readdirSync)(sourceDir, { withFileTypes: true });
+    (0, node_fs_1.mkdirSync)(destinationDir, { recursive: true });
+    for (const entry of entries) {
+        const sourcePath = node_path_1.default.join(sourceDir, entry.name);
+        const destinationPath = node_path_1.default.join(destinationDir, entry.name);
+        if (entry.isDirectory()) {
+            copyDirectoryContents(sourcePath, destinationPath);
+            continue;
+        }
+        if (entry.isFile()) {
+            (0, node_fs_1.mkdirSync)(node_path_1.default.dirname(destinationPath), { recursive: true });
+            (0, node_fs_1.copyFileSync)(sourcePath, destinationPath);
+        }
+    }
+}
+async function buildFrameworkSite(options) {
+    const resolvedConfig = (0, config_1.resolveConfig)(options.config ?? {});
+    const site = (0, site_1.resolveSitePaths)(options.rootDir, options.config ?? {});
+    const outDir = node_path_1.default.join(options.rootDir, "dist");
+    const manifestDir = node_path_1.default.join(outDir, "manifest");
+    const pagesOutDir = node_path_1.default.join(outDir, resolvedConfig.dirs.pages);
+    const serverOutDir = node_path_1.default.join(outDir, resolvedConfig.dirs.server);
+    const publicOutDir = node_path_1.default.join(outDir, resolvedConfig.dirs.public);
+    const layoutsOutDir = node_path_1.default.join(outDir, resolvedConfig.dirs.layouts);
+    const pageFiles = (0, site_1.findPageFiles)(site.pagesDir);
+    const actionFiles = (0, site_1.findActionFiles)(site.serverDir);
+    (0, node_fs_1.rmSync)(outDir, { recursive: true, force: true });
+    (0, node_fs_1.mkdirSync)(manifestDir, { recursive: true });
+    const actionFilesById = new Map(actionFiles.map((filePath) => {
+        const relativeToServerDir = node_path_1.default.relative(site.serverDir, filePath).split(node_path_1.default.sep).join("/");
+        return [(0, action_1.actionFilePathToActionId)(relativeToServerDir, ""), relativeToServerDir];
+    }));
+    const pagesManifest = pageFiles.map((filePath) => {
+        const relativeToPagesDir = node_path_1.default.relative(site.pagesDir, filePath).split(node_path_1.default.sep).join("/");
+        return {
+            file: relativeToPagesDir,
+            routePath: (0, routes_1.pagePathToRoutePath)(`${resolvedConfig.dirs.pages}/${relativeToPagesDir}`, resolvedConfig.dirs.pages),
+        };
+    }).sort((left, right) => left.routePath.localeCompare(right.routePath));
+    const actionsManifest = new Map();
+    function normalizeDeclaredActionId(target) {
+        const trimmed = String(target).trim();
+        if (!trimmed || /^https?:\/\//i.test(trimmed) || trimmed.toLowerCase().endsWith(".md")) {
+            return null;
+        }
+        return trimmed.replace(/^\/+/u, "");
+    }
+    function addManifestEntry(entry) {
+        actionsManifest.set(entry.id, entry);
+    }
+    function resolveActionsFileEntry(actionId) {
+        const directFile = actionFilesById.get(actionId);
+        if (directFile) {
+            return { id: actionId, file: directFile };
+        }
+        const segments = actionId.split("/").filter(Boolean);
+        const exportName = segments.pop();
+        if (!exportName) {
+            return null;
+        }
+        const actionsFileId = segments.length > 0 ? `${segments.join("/")}/actions` : "actions";
+        const actionsFile = actionFilesById.get(actionsFileId);
+        if (!actionsFile) {
+            return null;
+        }
+        return {
+            id: actionId,
+            file: actionsFile,
+            exportName,
+        };
+    }
+    for (const filePath of pageFiles) {
+        const pageSource = (0, node_fs_1.readFileSync)(filePath, "utf8");
+        let page;
+        try {
+            page = (0, page_definition_1.parsePageDefinition)(pageSource);
+        }
+        catch {
+            continue;
+        }
+        for (const block of page.blocks) {
+            for (const operation of [...block.reads, ...block.writes]) {
+                const actionId = normalizeDeclaredActionId(operation.target);
+                if (!actionId) {
+                    continue;
+                }
+                const entry = resolveActionsFileEntry(actionId);
+                if (entry) {
+                    addManifestEntry(entry);
+                }
+            }
+        }
+    }
+    for (const [actionId, relativeToServerDir] of actionFilesById.entries()) {
+        if (actionId === "actions" || actionId.endsWith("/actions")) {
+            continue;
+        }
+        if (!actionsManifest.has(actionId)) {
+            addManifestEntry({ id: actionId, file: relativeToServerDir });
+        }
+    }
+    const pagesManifestPath = node_path_1.default.join(manifestDir, "pages.json");
+    const actionsManifestPath = node_path_1.default.join(manifestDir, "actions.json");
+    (0, node_fs_1.writeFileSync)(pagesManifestPath, JSON.stringify(pagesManifest, null, 2) + "\n", "utf8");
+    (0, node_fs_1.writeFileSync)(actionsManifestPath, JSON.stringify(Array.from(actionsManifest.values()).sort((left, right) => left.id.localeCompare(right.id)), null, 2) + "\n", "utf8");
+    (0, node_fs_1.writeFileSync)(node_path_1.default.join(outDir, "mdsn.config.json"), JSON.stringify(resolvedConfig, null, 2) + "\n", "utf8");
+    try {
+        if ((0, node_fs_1.statSync)(site.pagesDir).isDirectory()) {
+            copyDirectoryContents(site.pagesDir, pagesOutDir);
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+    }
+    try {
+        if ((0, node_fs_1.statSync)(site.serverDir).isDirectory()) {
+            copyDirectoryContents(site.serverDir, serverOutDir);
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+    }
+    try {
+        if ((0, node_fs_1.statSync)(site.publicDir).isDirectory()) {
+            copyDirectoryContents(site.publicDir, publicOutDir);
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+    }
+    try {
+        if ((0, node_fs_1.statSync)(site.layoutsDir).isDirectory()) {
+            copyDirectoryContents(site.layoutsDir, layoutsOutDir);
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+    }
+    return {
+        outDir,
+        pagesManifestPath,
+        actionsManifestPath,
+    };
+}

package/dist/server/config.d.ts

@@ -0,0 +1,56 @@
+export type MdsnConfig = {
+    site?: {
+        title?: string;
+        description?: string;
+        baseUrl?: string;
+    };
+    server?: {
+        port?: number;
+    };
+    dirs?: {
+        pages?: string;
+        server?: string;
+        public?: string;
+        layouts?: string;
+    };
+    markdown?: {
+        linkify?: boolean;
+        typographer?: boolean;
+    };
+    dev?: {
+        openBrowser?: boolean;
+    };
+    i18n?: {
+        defaultLocale?: string;
+        locales?: string[];
+    };
+};
+export type ResolvedMdsnConfig = {
+    site: {
+        title?: string;
+        description?: string;
+        baseUrl?: string;
+    };
+    server: {
+        port: number;
+    };
+    dirs: {
+        pages: string;
+        server: string;
+        public: string;
+        layouts: string;
+    };
+    markdown: {
+        linkify: boolean;
+        typographer: boolean;
+    };
+    dev: {
+        openBrowser: boolean;
+    };
+    i18n: {
+        defaultLocale: string;
+        locales: string[];
+    };
+};
+export declare function defineConfig(config: MdsnConfig): MdsnConfig;
+export declare function resolveConfig(config: MdsnConfig): ResolvedMdsnConfig;