@mdsnai/sdk 0.1.0 → 0.2.1

package/dist/framework/hosted-app.d.ts

@@ -1,4 +1,5 @@
 import { type ActionHandler } from "../server/action-host";
+import { type SerializableBlock } from "../server/markdown";
 import { type RenderHostedPageOptions } from "../server/page-host";
 export interface CreateHostedAppOptions {
     pages: Record<string, string>;
@@ -6,8 +7,28 @@ export interface CreateHostedAppOptions {
         inputs: Record<string, unknown>;
     }>>;
     publicDir?: string;
+    errorFragments?: Partial<HostedAppErrorFragments>;
     render?: Omit<RenderHostedPageOptions, "accept" | "routePath" | "layoutTemplate"> & {
         resolveLayoutTemplate?: (routePath: string, rawPage: string) => string | undefined;
     };
 }
+export interface HostedAppErrorFragmentContext {
+    actionId: string;
+    block: SerializableBlock;
+    method: "GET" | "POST";
+    path: string;
+}
+export interface HostedAppActionNotAvailableContext extends HostedAppErrorFragmentContext {
+}
+export interface HostedAppUnsupportedContentTypeContext extends HostedAppErrorFragmentContext {
+    contentType: string;
+}
+export interface HostedAppInternalErrorContext extends HostedAppErrorFragmentContext {
+    error: unknown;
+}
+export interface HostedAppErrorFragments {
+    actionNotAvailable: (ctx: HostedAppActionNotAvailableContext) => string;
+    unsupportedContentType: (ctx: HostedAppUnsupportedContentTypeContext) => string;
+    internalError: (ctx: HostedAppInternalErrorContext) => string;
+}
 export declare function createHostedApp(options: CreateHostedAppOptions): import("express-serve-static-core").Express;

package/dist/framework/hosted-app.js

@@ -6,7 +6,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createHostedApp = createHostedApp;
 const express_1 = __importDefault(require("express"));
 const page_definition_1 = require("../core/document/page-definition");
+const block_1 = require("../core/model/block");
 const action_host_1 = require("../server/action-host");
+const action_inputs_1 = require("../server/action-inputs");
+const error_fragments_1 = require("../server/error-fragments");
 const page_links_1 = require("../server/page-links");
 const page_host_1 = require("../server/page-host");
 const negotiate_1 = require("../server/negotiate");
@@ -23,6 +26,9 @@ function normalizeActionId(target) {
     }
     return trimmed.replace(/^\/+/u, "");
 }
+function createActionBindingKey(method, path) {
+    return `${method}:${path}`;
+}
 function buildActionBindings(pages) {
     const bindings = new Map();
     for (const pageSource of Object.values(pages)) {
@@ -34,82 +40,166 @@ function buildActionBindings(pages) {
             continue;
         }
         for (const block of document.blocks) {
-            for (const operation of [...block.reads, ...block.writes]) {
+            for (const operation of block.reads) {
+                if (!operation.name || (0, block_1.isStreamAccept)(operation.accept)) {
+                    continue;
+                }
+                const targetPath = (0, page_links_1.mapPageTargetToHttpPath)(operation.target);
+                const actionId = normalizeActionId(operation.target);
+                if (!actionId) {
+                    continue;
+                }
+                const key = createActionBindingKey("GET", targetPath);
+                const existing = bindings.get(key);
+                if (existing
+                    && (existing.actionId !== actionId || existing.blockName !== block.name || existing.kind !== "read")) {
+                    throw new Error(`Action target must bind to one stable block context: GET ${targetPath}`);
+                }
+                bindings.set(key, {
+                    actionId,
+                    blockName: block.name,
+                    block,
+                    kind: "read",
+                });
+            }
+            for (const operation of block.writes) {
                 const targetPath = (0, page_links_1.mapPageTargetToHttpPath)(operation.target);
                 const actionId = normalizeActionId(operation.target);
                 if (!actionId) {
                     continue;
                 }
-                const existing = bindings.get(targetPath);
-                if (existing && (existing.actionId !== actionId || existing.blockName !== block.name)) {
-                    throw new Error(`Action target must bind to one stable block context: ${targetPath}`);
+                const key = createActionBindingKey("POST", targetPath);
+                const existing = bindings.get(key);
+                if (existing
+                    && (existing.actionId !== actionId || existing.blockName !== block.name || existing.kind !== "write")) {
+                    throw new Error(`Action target must bind to one stable block context: POST ${targetPath}`);
                 }
-                bindings.set(targetPath, {
+                bindings.set(key, {
                     actionId,
                     blockName: block.name,
+                    block,
+                    kind: "write",
                 });
             }
         }
     }
     return bindings;
 }
+function blockToSerializableBlock(block) {
+    return {
+        name: block.name,
+        inputs: block.inputs.map((input) => ({
+            name: input.name,
+            type: input.type,
+            required: input.required,
+            secret: input.secret,
+            options: input.options,
+        })),
+        reads: block.reads.map((read) => ({
+            name: read.name,
+            target: read.target,
+            inputs: read.inputs,
+            accept: read.accept,
+        })),
+        writes: block.writes.map((write) => ({
+            name: write.name,
+            target: write.target,
+            inputs: write.inputs,
+        })),
+    };
+}
+function sendActionFragment(reqAccept, status, markdown, binding, res, options) {
+    if ((0, negotiate_1.wantsMarkdown)(reqAccept) || !(0, negotiate_1.wantsHtml)(reqAccept)) {
+        res.status(status).type("text/markdown; charset=utf-8").send(markdown);
+        return;
+    }
+    res.status(status).type("text/html; charset=utf-8").send((0, fragment_render_1.renderBlockFragmentHtml)(markdown, binding.blockName, {
+        mapActionTarget: options.render?.mapActionTarget ?? page_links_1.mapPageTargetToHttpPath,
+        markdown: options.render?.markdown,
+    }));
+}
 function createHostedApp(options) {
     const app = (0, express_1.default)();
     const actionBindings = buildActionBindings(options.pages);
+    const errorFragments = {
+        actionNotAvailable: (ctx) => (0, error_fragments_1.renderActionNotAvailableFragment)({ block: ctx.block }),
+        unsupportedContentType: (ctx) => (0, error_fragments_1.renderUnsupportedContentTypeFragment)({ block: ctx.block }),
+        internalError: (ctx) => (0, error_fragments_1.renderInternalErrorFragment)({ block: ctx.block, error: ctx.error }),
+        ...options.errorFragments,
+    };
     const routedPages = (0, route_matcher_1.sortRoutedPagesForMatching)(Object.entries(options.pages).map(([routePath, source]) => ({
         routePath,
         source,
     })));
-    app.use(express_1.default.json());
+    app.use(express_1.default.text({
+        type: ["text/markdown"],
+        limit: "1mb",
+    }));
     if (typeof options.publicDir === "string") {
         app.use(express_1.default.static(options.publicDir));
     }
     app.get("/__mdsn/client.js", (_req, res) => {
         res.type("application/javascript; charset=utf-8").send((0, page_client_script_1.getPageClientRuntimeScript)());
     });
-    app.post("*", async (req, res, next) => {
-        const binding = actionBindings.get(req.path);
+    async function handleActionRequest(req, res, method, next) {
+        const binding = actionBindings.get(createActionBindingKey(method, req.path));
         if (!binding) {
             next();
             return;
         }
         const action = options.actions?.[binding.actionId];
         if (!action) {
-            res.status(404).json({
-                ok: false,
-                errorCode: "NOT_FOUND",
-            });
+            const block = blockToSerializableBlock(binding.block);
+            sendActionFragment(req.headers.accept, 404, errorFragments.actionNotAvailable({
+                actionId: binding.actionId,
+                block,
+                method,
+                path: req.path,
+            }), binding, res, options);
             return;
         }
         try {
-            const result = await (0, action_host_1.executeActionHandler)(action, {
-                inputs: (req.body?.inputs ?? {}),
-            });
-            if (result.ok && result.kind === "fragment") {
-                if ((0, negotiate_1.wantsMarkdown)(req.headers.accept)) {
-                    res.status(200).type("text/markdown; charset=utf-8").send(result.markdown);
+            if (method === "POST") {
+                const contentType = req.headers["content-type"] ?? "";
+                const normalized = String(contentType).toLowerCase();
+                if (!normalized.includes("text/markdown")) {
+                    const block = blockToSerializableBlock(binding.block);
+                    sendActionFragment(req.headers.accept, 415, errorFragments.unsupportedContentType({
+                        actionId: binding.actionId,
+                        block,
+                        method,
+                        path: req.path,
+                        contentType: String(contentType),
+                    }), binding, res, options);
                     return;
                 }
-                res.status(200).json({
-                    ...result,
-                    html: (0, fragment_render_1.renderBlockFragmentHtml)(result.markdown, binding.blockName, {
-                        mapActionTarget: options.render?.mapActionTarget ?? page_links_1.mapPageTargetToHttpPath,
-                        markdown: options.render?.markdown,
-                    }),
-                });
-                return;
             }
-            res.status(result.ok ? 200 : 400).json(result);
+            const result = await (0, action_host_1.executeActionHandler)(action, {
+                inputs: method === "GET"
+                    ? (0, action_inputs_1.parseActionInputs)(req.query)
+                    : (0, action_inputs_1.parseActionInputs)(typeof req.body === "string" ? req.body : ""),
+            });
+            sendActionFragment(req.headers.accept, 200, result, binding, res, options);
         }
         catch (error) {
-            res.status(500).json({
-                ok: false,
-                errorCode: "INTERNAL_ERROR",
-                message: error instanceof Error ? error.message : String(error),
-            });
+            sendActionFragment(req.headers.accept, 500, errorFragments.internalError({
+                actionId: binding.actionId,
+                block: blockToSerializableBlock(binding.block),
+                method,
+                path: req.path,
+                error,
+            }), binding, res, options);
         }
+    }
+    app.post("*", async (req, res, next) => {
+        await handleActionRequest(req, res, "POST", next);
     });
-    app.get("*", (req, res) => {
+    app.get("*", async (req, res) => {
+        const actionBinding = actionBindings.get(createActionBindingKey("GET", req.path));
+        if (actionBinding) {
+            await handleActionRequest(req, res, "GET", () => undefined);
+            return;
+        }
         const matchedPage = (0, route_matcher_1.resolveRoutedPageForPath)(req.path, routedPages);
         if (!matchedPage) {
             res.status(404).type("text/plain; charset=utf-8").send("Not Found");

package/dist/framework/index.d.ts

@@ -1,4 +1,6 @@
+export { createHostedApp } from "./hosted-app";
 export { createFrameworkApp } from "./create-framework-app";
+export type { CreateHostedAppOptions } from "./hosted-app";
 export type { CreateFrameworkAppOptions } from "./create-framework-app";
 export { defineConfig } from "../server/config";
 export type { MdsnConfig } from "../server/config";

package/dist/framework/index.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defineConfig = exports.createFrameworkApp = void 0;
+exports.defineConfig = exports.createFrameworkApp = exports.createHostedApp = void 0;
+var hosted_app_1 = require("./hosted-app");
+Object.defineProperty(exports, "createHostedApp", { enumerable: true, get: function () { return hosted_app_1.createHostedApp; } });
 var create_framework_app_1 = require("./create-framework-app");
 Object.defineProperty(exports, "createFrameworkApp", { enumerable: true, get: function () { return create_framework_app_1.createFrameworkApp; } });
 var config_1 = require("../server/config");

package/dist/framework/site-app.d.ts

@@ -8,5 +8,6 @@ export interface CreateSiteAppOptions {
     rootDir: string;
     config?: MdsnConfig;
     actions?: CreateHostedAppOptions["actions"];
+    errorFragments?: CreateHostedAppOptions["errorFragments"];
 }
 export declare function createSiteApp(options: CreateSiteAppOptions): import("express-serve-static-core").Express;

package/dist/framework/site-app.js

@@ -132,6 +132,7 @@ function createSiteApp(options) {
         pages,
         actions,
         publicDir,
+        errorFragments: options.errorFragments,
         render: {
             siteTitle: resolvedConfig.site.title,
             siteDescription: resolvedConfig.site.description,

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 export { parsePageDefinition } from "./core";
-export type { BlockAnchorDefinition, BlockDefinition, DocumentDefinition, FrontmatterData, InputDefinition, InputType, ReadDefinition, RedirectDefinition, SchemaDefinition, WriteDefinition, } from "./core";
+export type { BlockAnchorDefinition, BlockDefinition, DocumentDefinition, FrontmatterData, InputDefinition, InputType, ReadDefinition, 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";
+export { createHostedApp, createFrameworkApp, defineConfig, } from "./framework";
+export type { CreateHostedAppOptions, CreateFrameworkAppOptions, MdsnConfig, } from "./framework";
+export { HttpCookieJar, createActionContextFromRequest, defineAction, defineActions, parseActionInputs, parseCookieHeader, renderActionNotAvailableFragment, renderAuthRequiredFragment, renderErrorFragment, renderHostedPage, renderInternalErrorFragment, renderMarkdownFragment, renderMarkdownValue, renderUnsupportedContentTypeFragment, requireSessionFromCookie, serializeActionInputsAsMarkdown, serializeBlock, } from "./server";
+export type { ActionContext, ActionDefinition, ActionDefinitionMap, CreateActionContextFromRequestOptions, HostedPageResponse, SerializableBlock, SerializableInput, SerializableRead, SerializableWrite, } from "./server";

package/dist/index.js

@@ -1,6 +1,6 @@
 "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;
+exports.serializeBlock = exports.serializeActionInputsAsMarkdown = exports.requireSessionFromCookie = exports.renderUnsupportedContentTypeFragment = exports.renderMarkdownValue = exports.renderMarkdownFragment = exports.renderInternalErrorFragment = exports.renderHostedPage = exports.renderErrorFragment = exports.renderAuthRequiredFragment = exports.renderActionNotAvailableFragment = exports.parseCookieHeader = exports.parseActionInputs = exports.defineActions = exports.defineAction = exports.createActionContextFromRequest = exports.HttpCookieJar = exports.defineConfig = exports.createFrameworkApp = exports.createHostedApp = 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");
@@ -12,7 +12,24 @@ Object.defineProperty(exports, "parsePage", { enumerable: true, get: function ()
 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, "createHostedApp", { enumerable: true, get: function () { return framework_1.createHostedApp; } });
 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, "HttpCookieJar", { enumerable: true, get: function () { return server_1.HttpCookieJar; } });
+Object.defineProperty(exports, "createActionContextFromRequest", { enumerable: true, get: function () { return server_1.createActionContextFromRequest; } });
 Object.defineProperty(exports, "defineAction", { enumerable: true, get: function () { return server_1.defineAction; } });
+Object.defineProperty(exports, "defineActions", { enumerable: true, get: function () { return server_1.defineActions; } });
+Object.defineProperty(exports, "parseActionInputs", { enumerable: true, get: function () { return server_1.parseActionInputs; } });
+Object.defineProperty(exports, "parseCookieHeader", { enumerable: true, get: function () { return server_1.parseCookieHeader; } });
+Object.defineProperty(exports, "renderActionNotAvailableFragment", { enumerable: true, get: function () { return server_1.renderActionNotAvailableFragment; } });
+Object.defineProperty(exports, "renderAuthRequiredFragment", { enumerable: true, get: function () { return server_1.renderAuthRequiredFragment; } });
+Object.defineProperty(exports, "renderErrorFragment", { enumerable: true, get: function () { return server_1.renderErrorFragment; } });
+Object.defineProperty(exports, "renderHostedPage", { enumerable: true, get: function () { return server_1.renderHostedPage; } });
+Object.defineProperty(exports, "renderInternalErrorFragment", { enumerable: true, get: function () { return server_1.renderInternalErrorFragment; } });
+Object.defineProperty(exports, "renderMarkdownFragment", { enumerable: true, get: function () { return server_1.renderMarkdownFragment; } });
+Object.defineProperty(exports, "renderMarkdownValue", { enumerable: true, get: function () { return server_1.renderMarkdownValue; } });
+Object.defineProperty(exports, "renderUnsupportedContentTypeFragment", { enumerable: true, get: function () { return server_1.renderUnsupportedContentTypeFragment; } });
+Object.defineProperty(exports, "requireSessionFromCookie", { enumerable: true, get: function () { return server_1.requireSessionFromCookie; } });
+Object.defineProperty(exports, "serializeActionInputsAsMarkdown", { enumerable: true, get: function () { return server_1.serializeActionInputsAsMarkdown; } });
+Object.defineProperty(exports, "serializeBlock", { enumerable: true, get: function () { return server_1.serializeBlock; } });

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

@@ -0,0 +1,11 @@
+import type express from "express";
+import type { ActionContext } from "./action";
+export interface CreateActionContextFromRequestOptions {
+    inputs?: Record<string, unknown>;
+    pathname?: string;
+    cookies?: Record<string, string>;
+    env?: Record<string, string | undefined>;
+    siteTitle?: string;
+    siteBaseUrl?: string;
+}
+export declare function createActionContextFromRequest(req: express.Request, options?: CreateActionContextFromRequestOptions): ActionContext;

package/dist/server/action-context.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createActionContextFromRequest = createActionContextFromRequest;
+function createActionContextFromRequest(req, options = {}) {
+    const body = (req.body ?? {});
+    return {
+        inputs: options.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: options.pathname ?? (typeof body.pathname === "string" ? body.pathname : req.path),
+        request: req,
+        cookies: options.cookies ?? {},
+        env: options.env ?? process.env,
+        site: {
+            title: options.siteTitle,
+            baseUrl: options.siteBaseUrl,
+        },
+    };
+}

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

@@ -1,3 +1,2 @@
-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>;
+export type ActionHandler<Context = unknown> = (ctx: Context) => Promise<string> | string;
+export declare function executeActionHandler<Context>(handler: ActionHandler<Context>, ctx?: Context): Promise<string>;

package/dist/server/action-host.js

@@ -1,8 +1,10 @@
 "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);
+    if (typeof result !== "string") {
+        throw new Error("Invalid action result: expected markdown string");
+    }
+    return result;
 }

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

@@ -0,0 +1,3 @@
+export declare function serializeActionInputsAsMarkdown(inputs: Record<string, unknown>): string;
+export declare function parseActionInputs(payload: unknown): Record<string, unknown>;
+export declare function normalizeActionInputPayloadToMarkdown(payload: unknown): string;

package/dist/server/action-inputs.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeActionInputsAsMarkdown = serializeActionInputsAsMarkdown;
+exports.parseActionInputs = parseActionInputs;
+exports.normalizeActionInputPayloadToMarkdown = normalizeActionInputPayloadToMarkdown;
+const core_1 = require("../core");
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseScalarToken(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return "";
+    }
+    (0, core_1.validateInputLength)(trimmed, core_1.MAX_INPUT_LENGTH);
+    if (trimmed.startsWith("{")
+        || trimmed.startsWith("[")
+        || trimmed.startsWith("\"")
+        || trimmed === "true"
+        || trimmed === "false"
+        || trimmed === "null"
+        || /^-?\d+(\.\d+)?([eE][+-]?\d+)?$/u.test(trimmed)) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            // Fall through to plain string.
+        }
+    }
+    if ((trimmed.startsWith("'") && trimmed.endsWith("'"))
+        || (trimmed.startsWith("\"") && trimmed.endsWith("\""))) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function parseMarkdownInputs(source) {
+    (0, core_1.validateInputLength)(source, core_1.MAX_INPUT_LENGTH * 10);
+    const inputs = {};
+    const segments = splitInputPairs(source);
+    for (const segment of segments) {
+        const separator = segment.indexOf(":");
+        if (separator <= 0) {
+            continue;
+        }
+        const name = segment.slice(0, separator).trim();
+        if (!/^[a-zA-Z_][\w-]*$/u.test(name)) {
+            continue;
+        }
+        if (name.length > core_1.MAX_IDENTIFIER_LENGTH) {
+            continue;
+        }
+        const value = segment.slice(separator + 1);
+        inputs[name] = parseScalarToken(value);
+    }
+    return inputs;
+}
+function splitInputPairs(source) {
+    const pairs = [];
+    let current = "";
+    let depthObject = 0;
+    let depthArray = 0;
+    let inSingleQuote = false;
+    let inDoubleQuote = false;
+    let escaped = false;
+    const flushCurrent = () => {
+        const trimmed = current.trim();
+        if (trimmed) {
+            pairs.push(trimmed);
+        }
+        current = "";
+    };
+    for (const char of source) {
+        if (escaped) {
+            current += char;
+            escaped = false;
+            continue;
+        }
+        if (inSingleQuote) {
+            current += char;
+            if (char === "\\") {
+                escaped = true;
+            }
+            else if (char === "'") {
+                inSingleQuote = false;
+            }
+            continue;
+        }
+        if (inDoubleQuote) {
+            current += char;
+            if (char === "\\") {
+                escaped = true;
+            }
+            else if (char === "\"") {
+                inDoubleQuote = false;
+            }
+            continue;
+        }
+        if (char === "'") {
+            inSingleQuote = true;
+            current += char;
+            continue;
+        }
+        if (char === "\"") {
+            inDoubleQuote = true;
+            current += char;
+            continue;
+        }
+        if (char === "{") {
+            depthObject += 1;
+            current += char;
+            continue;
+        }
+        if (char === "}") {
+            depthObject = Math.max(0, depthObject - 1);
+            current += char;
+            continue;
+        }
+        if (char === "[") {
+            depthArray += 1;
+            current += char;
+            continue;
+        }
+        if (char === "]") {
+            depthArray = Math.max(0, depthArray - 1);
+            current += char;
+            continue;
+        }
+        const isTopLevel = depthObject === 0 && depthArray === 0;
+        if (isTopLevel && (char === "," || char === "，" || char === "\n" || char === "\r")) {
+            flushCurrent();
+            continue;
+        }
+        current += char;
+    }
+    flushCurrent();
+    return pairs;
+}
+function normalizeObjectInputs(payload) {
+    const inputs = {};
+    for (const [name, value] of Object.entries(payload)) {
+        if (!/^[a-zA-Z_][\w-]*$/u.test(name)) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            if (value.length > 0) {
+                inputs[name] = value[0];
+            }
+            continue;
+        }
+        if (typeof value === "string") {
+            inputs[name] = parseScalarToken(value);
+            continue;
+        }
+        if (typeof value === "number" || typeof value === "boolean") {
+            inputs[name] = value;
+            continue;
+        }
+    }
+    return inputs;
+}
+function serializeActionInputsAsMarkdown(inputs) {
+    return Object.entries(inputs)
+        .filter(([, value]) => value !== undefined)
+        .map(([name, value]) => `${name}: ${JSON.stringify(value)}`)
+        .join(", ");
+}
+function parseActionInputs(payload) {
+    if (typeof payload === "string") {
+        return parseMarkdownInputs(payload);
+    }
+    if (isPlainObject(payload)) {
+        return normalizeObjectInputs(payload);
+    }
+    return {};
+}
+function normalizeActionInputPayloadToMarkdown(payload) {
+    return serializeActionInputsAsMarkdown(parseActionInputs(payload));
+}

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

@@ -1,8 +1,8 @@
-import type express from "express";
-import { type ActionContext, type ActionRegistry } from "./action";
+import { type ActionRegistry } from "./action";
+import { createActionContextFromRequest } from "./action-context";
 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;
+export declare function createActionContext(req: Parameters<typeof createActionContextFromRequest>[0], siteTitle?: string, siteBaseUrl?: string): import("./action").ActionContext;

package/dist/server/action-runtime.js

@@ -10,6 +10,7 @@ exports.createActionContext = createActionContext;
 const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
 const action_1 = require("./action");
+const action_context_1 = require("./action-context");
 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("/");
@@ -57,25 +58,5 @@ async function loadActionRegistry(actionFiles, actionsDir, options = {}) {
     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,
-        },
-    };
+    return (0, action_context_1.createActionContextFromRequest)(req, { siteTitle, siteBaseUrl });
 }

package/dist/server/action.d.ts

@@ -1,4 +1,3 @@
-import type { ActionResult as HostedActionResult } from "../core/action";
 export type ActionContext = {
     inputs: Record<string, unknown>;
     params: Record<string, string>;
@@ -12,14 +11,7 @@ export type ActionContext = {
         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 ActionReturnValue = string;
 export type ActionDefinition = {
     name?: string;
     auth?: boolean;