@mdsnai/sdk 0.1.0 → 0.2.0

package/README.md

@@ -4,6 +4,37 @@
 
 MDSN keeps page content and page interaction in the same source by combining a Markdown body with an executable `mdsn` block.
 
+## Start With One Package
+
+For most projects, start with:
+
+```ts
+import { createFrameworkApp, defineConfig } from "@mdsnai/sdk";
+```
+
+```ts
+import {
+  createHostedApp,
+  createActionContextFromRequest,
+  defineActions,
+  renderHostedPage,
+  renderMarkdownFragment,
+  renderMarkdownValue,
+} from "@mdsnai/sdk";
+```
+
+```ts
+import { parsePage, parseFragment } from "@mdsnai/sdk";
+```
+
+Use the root entry point for the common paths:
+
+- build a site with the built-in framework
+- host MDSN pages and actions inside your own server
+- render the UI yourself with React or Vue
+
+Move to `@mdsnai/sdk/framework`, `@mdsnai/sdk/server`, `@mdsnai/sdk/web`, or `@mdsnai/sdk/core` only when you want stricter boundaries or narrower imports.
+
 ## Why MDSN
 
 Plain Markdown is good for content, but weak at expressing interaction.
@@ -12,6 +43,14 @@ Once a page needs inputs, actions, partial updates, or navigation, that structur
 
 MDSN makes that interaction layer explicit while keeping the page source readable for humans, AI agents, and agentic AI systems.
 
+In MDSN, page content is not just presentation. It is also shared prompt context for AI agents.
+
+That means the same Markdown source can carry:
+
+- content for humans to read
+- state and task context for AI agents to interpret
+- explicit interaction structure for both sides to continue from
+
 ## What This Package Includes
 
 - the MDSN parser and core model
@@ -63,5 +102,6 @@ The starter generates a minimal runnable site with:
 - [Getting Started](https://docs.mdsn.ai/docs/getting-started)
 - [Framework Development](https://docs.mdsn.ai/docs/site-development)
 - [Server Development](https://docs.mdsn.ai/docs/server-development)
+- [HTTP Content Negotiation and Shared Interaction](https://docs.mdsn.ai/docs/shared-interaction)
 - [Action Reference](https://docs.mdsn.ai/docs/action-reference)
 - [SDK Reference](https://docs.mdsn.ai/docs/sdk-reference)

package/dist/core/document/markdown.js

@@ -2,9 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractExecutableMdsnBlocks = extractExecutableMdsnBlocks;
 exports.extractBlockAnchors = extractBlockAnchors;
-function trimTrailingBlankLines(value) {
-    return value.replace(/\n+$/u, "\n");
-}
+const utils_1 = require("../utils");
 function extractExecutableMdsnBlocks(markdown) {
     const lines = markdown.split(/\r?\n/);
     const keptLines = [];
@@ -49,7 +47,7 @@ function extractExecutableMdsnBlocks(markdown) {
         index += 1;
     }
     return {
-        markdownWithoutMdsn: trimTrailingBlankLines(keptLines.join("\n")),
+        markdownWithoutMdsn: (0, utils_1.trimTrailingBlankLines)(keptLines.join("\n")),
         blocks,
     };
 }

package/dist/core/document/page-definition.js

@@ -13,11 +13,10 @@ function parsePageDefinition(raw) {
     }
     const parsed = (0, mdsn_1.parseMdsnBlocks)(blocks);
     const blockAnchors = (0, markdown_1.extractBlockAnchors)(markdownWithoutMdsn).map((name) => ({ name }));
-    (0, validation_1.validateDocumentStructure)(parsed.schemas, parsed.blocks, blockAnchors);
+    (0, validation_1.validateDocumentStructure)(parsed.blocks, blockAnchors);
     return {
         frontmatter,
         markdown: markdownWithoutMdsn,
-        schemas: parsed.schemas,
         blocks: parsed.blocks,
         blockAnchors,
     };

package/dist/core/index.d.ts

@@ -1,3 +1,4 @@
 export { parsePageDefinition } from "./document/page-definition";
 export type { FrontmatterData } from "./model/document";
-export type { BlockAnchorDefinition, BlockDefinition, DocumentDefinition, InputDefinition, InputType, ReadDefinition, RedirectDefinition, SchemaDefinition, WriteDefinition, } from "./model";
+export type { BlockAnchorDefinition, BlockDefinition, DocumentDefinition, InputDefinition, InputType, ReadDefinition, WriteDefinition, } from "./model";
+export { escapeHtml, escapeRegExp, validateInputLength, trimTrailingBlankLines, MAX_INPUT_LENGTH, MAX_IDENTIFIER_LENGTH, createLogger, type Logger, type LogLevel, type CreateLoggerOptions, } from "./utils";

package/dist/core/index.js

@@ -1,5 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parsePageDefinition = void 0;
+exports.createLogger = exports.MAX_IDENTIFIER_LENGTH = exports.MAX_INPUT_LENGTH = exports.trimTrailingBlankLines = exports.validateInputLength = exports.escapeRegExp = exports.escapeHtml = exports.parsePageDefinition = void 0;
 var page_definition_1 = require("./document/page-definition");
 Object.defineProperty(exports, "parsePageDefinition", { enumerable: true, get: function () { return page_definition_1.parsePageDefinition; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "escapeHtml", { enumerable: true, get: function () { return utils_1.escapeHtml; } });
+Object.defineProperty(exports, "escapeRegExp", { enumerable: true, get: function () { return utils_1.escapeRegExp; } });
+Object.defineProperty(exports, "validateInputLength", { enumerable: true, get: function () { return utils_1.validateInputLength; } });
+Object.defineProperty(exports, "trimTrailingBlankLines", { enumerable: true, get: function () { return utils_1.trimTrailingBlankLines; } });
+Object.defineProperty(exports, "MAX_INPUT_LENGTH", { enumerable: true, get: function () { return utils_1.MAX_INPUT_LENGTH; } });
+Object.defineProperty(exports, "MAX_IDENTIFIER_LENGTH", { enumerable: true, get: function () { return utils_1.MAX_IDENTIFIER_LENGTH; } });
+Object.defineProperty(exports, "createLogger", { enumerable: true, get: function () { return utils_1.createLogger; } });

package/dist/core/model/block.d.ts

@@ -1,10 +1,13 @@
 import type { InputDefinition } from "./input";
+export declare const STREAM_ACCEPT = "text/event-stream";
+export declare function isStreamAccept(accept?: string): boolean;
 export interface ReadDefinition {
     id: string;
     block: string;
-    name: string;
+    name?: string;
     target: string;
     inputs: string[];
+    accept?: string;
     order: number;
 }
 export interface WriteDefinition {
@@ -15,16 +18,9 @@ export interface WriteDefinition {
     inputs: string[];
     order: number;
 }
-export interface RedirectDefinition {
-    id: string;
-    block: string;
-    target: string;
-    order: number;
-}
 export interface BlockDefinition {
     name: string;
     inputs: InputDefinition[];
     reads: ReadDefinition[];
     writes: WriteDefinition[];
-    redirects: RedirectDefinition[];
 }

package/dist/core/model/block.js

@@ -1,2 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.STREAM_ACCEPT = void 0;
+exports.isStreamAccept = isStreamAccept;
+exports.STREAM_ACCEPT = "text/event-stream";
+function isStreamAccept(accept) {
+    return String(accept ?? "").toLowerCase() === exports.STREAM_ACCEPT;
+}

package/dist/core/model/document.d.ts

@@ -1,5 +1,4 @@
 import type { BlockDefinition } from "./block";
-import type { SchemaDefinition } from "./schema";
 export type FrontmatterData = Record<string, unknown>;
 export interface BlockAnchorDefinition {
     name: string;
@@ -7,7 +6,6 @@ export interface BlockAnchorDefinition {
 export interface DocumentDefinition {
     frontmatter: FrontmatterData;
     markdown: string;
-    schemas: SchemaDefinition[];
     blocks: BlockDefinition[];
     blockAnchors: BlockAnchorDefinition[];
 }

package/dist/core/model/index.d.ts

@@ -1,5 +1,4 @@
 export type { BlockAnchorDefinition, DocumentDefinition, FrontmatterData, } from "./document";
-export type { BlockDefinition, ReadDefinition, RedirectDefinition, WriteDefinition, } from "./block";
+export type { BlockDefinition, ReadDefinition, WriteDefinition, } from "./block";
 export type { InputDefinition, InputType, } from "./input";
-export type { SchemaDefinition } from "./schema";
 export type { MarkdownFragmentDefinition } from "./fragment";

package/dist/core/model/input.d.ts

@@ -1,4 +1,4 @@
-export type InputType = "text" | "number" | "boolean" | "choice" | "file" | "json";
+export type InputType = "text" | "number" | "boolean" | "choice" | "asset";
 export interface InputDefinition {
     id: string;
     block: string;
@@ -7,5 +7,4 @@ export interface InputDefinition {
     required: boolean;
     secret: boolean;
     options?: string[];
-    schema?: string;
 }

package/dist/core/protocol/mdsn.d.ts

@@ -1,6 +1,4 @@
 import type { BlockDefinition } from "../model/block";
-import type { SchemaDefinition } from "../model/schema";
 export declare function parseMdsnBlocks(blocks: string[]): {
-    schemas: SchemaDefinition[];
     blocks: BlockDefinition[];
 };

package/dist/core/protocol/mdsn.js

@@ -8,11 +8,9 @@ function createBlock(name) {
         inputs: [],
         reads: [],
         writes: [],
-        redirects: [],
     };
 }
 function parseMdsnBlocks(blocks) {
-    const schemas = [];
     const documentBlocks = [];
     let currentBlock = null;
     for (const blockText of blocks) {
@@ -25,12 +23,6 @@ function parseMdsnBlocks(blocks) {
                 continue;
             }
             if (!currentBlock) {
-                if (line.startsWith("schema ")) {
-                    const parsed = (0, statements_1.parseSchemaBlock)(lines, index);
-                    schemas.push(parsed.schema);
-                    index = parsed.nextIndex;
-                    continue;
-                }
                 if (line.startsWith("block ")) {
                     currentBlock = createBlock((0, statements_1.parseBlockHeaderLine)(line));
                     documentBlocks.push(currentBlock);
@@ -47,26 +39,21 @@ function parseMdsnBlocks(blocks) {
                 index += 1;
                 continue;
             }
-            if (line.startsWith("input ")) {
+            if (line.startsWith("INPUT ")) {
                 currentBlock.inputs.push((0, statements_1.parseInputLine)(line, currentBlock.name));
                 index += 1;
                 continue;
             }
-            if (line.startsWith("read ")) {
+            if (line.startsWith("GET ")) {
                 currentBlock.reads.push((0, statements_1.parseReadOrWriteLine)(line, "read", currentBlock.name, (0, statements_1.getNextOperationOrder)(currentBlock)));
                 index += 1;
                 continue;
             }
-            if (line.startsWith("write ")) {
+            if (line.startsWith("POST ")) {
                 currentBlock.writes.push((0, statements_1.parseReadOrWriteLine)(line, "write", currentBlock.name, (0, statements_1.getNextOperationOrder)(currentBlock)));
                 index += 1;
                 continue;
             }
-            if (line.startsWith("redirect ")) {
-                currentBlock.redirects.push((0, statements_1.parseRedirectLine)(line, currentBlock.name, (0, statements_1.getNextOperationOrder)(currentBlock)));
-                index += 1;
-                continue;
-            }
             throw new Error(`Unsupported MDSN statement: ${line}`);
         }
     }
@@ -74,7 +61,6 @@ function parseMdsnBlocks(blocks) {
         throw new Error(`Unterminated block declaration: ${currentBlock.name}`);
     }
     return {
-        schemas,
         blocks: documentBlocks,
     };
 }

package/dist/core/protocol/statements.d.ts

@@ -1,12 +1,7 @@
-import type { BlockDefinition, ReadDefinition, RedirectDefinition, WriteDefinition } from "../model/block";
+import { type BlockDefinition, type ReadDefinition, type WriteDefinition } from "../model/block";
 import type { InputDefinition } from "../model/input";
-import type { SchemaDefinition } from "../model/schema";
 export declare function parseBlockHeaderLine(line: string): string;
 export declare function parseInputLine(line: string, blockName: string): InputDefinition;
-export declare function parseReadOrWriteLine(line: string, kind: "read" | "write", blockName: string, index: number): ReadDefinition | WriteDefinition;
-export declare function parseRedirectLine(line: string, blockName: string, index: number): RedirectDefinition;
-export declare function parseSchemaBlock(lines: string[], startIndex: number): {
-    schema: SchemaDefinition;
-    nextIndex: number;
-};
+export declare function parseReadOrWriteLine(line: string, kind: "read", blockName: string, index: number): ReadDefinition;
+export declare function parseReadOrWriteLine(line: string, kind: "write", blockName: string, index: number): WriteDefinition;
 export declare function getNextOperationOrder(block: BlockDefinition): number;

package/dist/core/protocol/statements.js

@@ -3,9 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseBlockHeaderLine = parseBlockHeaderLine;
 exports.parseInputLine = parseInputLine;
 exports.parseReadOrWriteLine = parseReadOrWriteLine;
-exports.parseRedirectLine = parseRedirectLine;
-exports.parseSchemaBlock = parseSchemaBlock;
 exports.getNextOperationOrder = getNextOperationOrder;
+const block_1 = require("../model/block");
 function isIdentifier(value) {
     return /^[a-zA-Z_][\w-]*$/.test(value);
 }
@@ -28,13 +27,6 @@ function parseStringArrayLiteral(raw) {
     }
     return parsed;
 }
-function parseSchemaLiteral(raw) {
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-        throw new Error("Schema body must be a JSON object");
-    }
-    return parsed;
-}
 function parseBlockHeaderLine(line) {
     const match = line.trim().match(/^block\s+([a-zA-Z_][\w-]*)\s*\{$/);
     if (!match) {
@@ -43,46 +35,71 @@ function parseBlockHeaderLine(line) {
     return match[1];
 }
 function parseInputLine(line, blockName) {
-    const match = line
-        .trim()
-        .match(/^input\s+([a-zA-Z_][\w-]*)(!)?:\s*(text|number|boolean|choice|file|json)(?:\s+(secret))?(?:\s+(\[.*\]))?(?:\s+([a-zA-Z_][\w-]*))?$/);
+    const match = line.trim().match(/^INPUT\s+(text|number|boolean|choice|asset)(?:\s+(.*?))?\s*->\s*([a-zA-Z_][\w-]*)$/);
     if (!match) {
         throw new Error(`Invalid input declaration: ${line}`);
     }
-    const [, name, requiredMarker, type, secretMarker, optionsLiteral, schemaName] = match;
+    const [, type, trailing, name] = match;
+    const tail = (trailing ?? "").trim();
+    const required = /\brequired\b/u.test(tail);
+    const secret = /\bsecret\b/u.test(tail);
+    const optionsMatch = tail.match(/(\[.*\])/u);
+    const optionsLiteral = optionsMatch?.[1];
+    const normalizedTail = tail
+        .replace(/\brequired\b/gu, "")
+        .replace(/\bsecret\b/gu, "")
+        .replace(/(\[.*\])/u, "")
+        .trim();
+    if (normalizedTail) {
+        throw new Error(`Invalid input declaration: ${line}`);
+    }
     const input = {
         id: `${blockName}::input::${name}`,
         block: blockName,
         name,
         type: type,
-        required: requiredMarker === "!",
-        secret: secretMarker === "secret",
+        required,
+        secret,
     };
     if (optionsLiteral) {
         input.options = parseStringArrayLiteral(optionsLiteral);
     }
-    if (schemaName) {
-        input.schema = schemaName;
-    }
     if (input.type === "choice" && (!input.options || input.options.length === 0)) {
         throw new Error(`Choice input ${name} in block ${blockName} must define options`);
     }
-    if (input.type === "json" && !input.schema) {
-        throw new Error(`JSON input ${name} in block ${blockName} must define schema`);
+    if (input.type !== "choice" && input.options) {
+        throw new Error(`Only choice input ${name} in block ${blockName} can define options`);
     }
     return input;
 }
 function parseReadOrWriteLine(line, kind, blockName, index) {
-    const match = line
-        .trim()
-        .match(/^(read|write)\s+([a-zA-Z_][\w-]*)\s*:\s*"([^"]+)"(?:\s*\(([^)]*)\))?$/);
+    if (kind === "read") {
+        const match = line.trim().match(/^GET\s+"([^"]+)"(?:\s*\(([^)]*)\))?(?:\s+accept:"([^"]+)")?(?:\s*->\s*([a-zA-Z_][\w-]*))?$/);
+        if (!match) {
+            throw new Error(`Invalid ${kind} declaration: ${line}`);
+        }
+        const [, target, rawInputs, accept, name] = match;
+        if (!name && !(0, block_1.isStreamAccept)(accept)) {
+            throw new Error(`Invalid ${kind} declaration: ${line}`);
+        }
+        if ((0, block_1.isStreamAccept)(accept) && name) {
+            throw new Error(`Invalid ${kind} declaration: ${line}`);
+        }
+        return {
+            id: `${blockName}::${kind}::${index}`,
+            block: blockName,
+            name,
+            target,
+            inputs: parseIdentifierList(rawInputs ?? ""),
+            accept,
+            order: index,
+        };
+    }
+    const match = line.trim().match(/^POST\s+"([^"]+)"\s*\(([^)]*)\)\s*->\s*([a-zA-Z_][\w-]*)$/);
     if (!match) {
         throw new Error(`Invalid ${kind} declaration: ${line}`);
     }
-    const [, parsedKind, name, target, rawInputs] = match;
-    if (parsedKind !== kind) {
-        throw new Error(`Expected ${kind} declaration: ${line}`);
-    }
+    const [, target, rawInputs, name] = match;
     const base = {
         id: `${blockName}::${kind}::${index}`,
         block: blockName,
@@ -91,50 +108,8 @@ function parseReadOrWriteLine(line, kind, blockName, index) {
         inputs: parseIdentifierList(rawInputs ?? ""),
         order: index,
     };
-    return kind === "read" ? base : base;
-}
-function parseRedirectLine(line, blockName, index) {
-    const match = line.trim().match(/^redirect\s+"([^"]+)"$/);
-    if (!match) {
-        throw new Error(`Invalid redirect declaration: ${line}`);
-    }
-    return {
-        id: `${blockName}::redirect::${index}`,
-        block: blockName,
-        target: match[1],
-        order: index,
-    };
-}
-function parseSchemaBlock(lines, startIndex) {
-    const firstLine = lines[startIndex].trim();
-    const match = firstLine.match(/^schema\s+([a-zA-Z_][\w-]*)\s*(\{.*)?$/);
-    if (!match) {
-        throw new Error(`Invalid schema declaration: ${firstLine}`);
-    }
-    const name = match[1];
-    let literal = (match[2] ?? "").trim();
-    let braceDepth = (literal.match(/\{/g) ?? []).length - (literal.match(/\}/g) ?? []).length;
-    let index = startIndex;
-    while (braceDepth > 0) {
-        index += 1;
-        if (index >= lines.length) {
-            throw new Error(`Unterminated schema declaration: ${name}`);
-        }
-        literal += "\n" + lines[index];
-        braceDepth += (lines[index].match(/\{/g) ?? []).length;
-        braceDepth -= (lines[index].match(/\}/g) ?? []).length;
-    }
-    if (!literal.startsWith("{")) {
-        throw new Error(`schema ${name} must start with {`);
-    }
-    return {
-        schema: {
-            name,
-            shape: parseSchemaLiteral(literal),
-        },
-        nextIndex: index + 1,
-    };
+    return base;
 }
 function getNextOperationOrder(block) {
-    return block.reads.length + block.writes.length + block.redirects.length;
+    return block.reads.length + block.writes.length;
 }

package/dist/core/protocol/validation.d.ts

@@ -1,4 +1,3 @@
-import type { BlockDefinition } from "../model/block";
+import { type BlockDefinition } from "../model/block";
 import type { BlockAnchorDefinition } from "../model/document";
-import type { SchemaDefinition } from "../model/schema";
-export declare function validateDocumentStructure(schemas: SchemaDefinition[], blocks: BlockDefinition[], blockAnchors: BlockAnchorDefinition[]): void;
+export declare function validateDocumentStructure(blocks: BlockDefinition[], blockAnchors: BlockAnchorDefinition[]): void;

package/dist/core/protocol/validation.js

@@ -1,14 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateDocumentStructure = validateDocumentStructure;
-function validateDocumentStructure(schemas, blocks, blockAnchors) {
-    const schemaNames = new Set();
-    for (const schema of schemas) {
-        if (schemaNames.has(schema.name)) {
-            throw new Error(`Duplicate schema name: ${schema.name}`);
-        }
-        schemaNames.add(schema.name);
-    }
+const block_1 = require("../model/block");
+function validateDocumentStructure(blocks, blockAnchors) {
     const blockNames = new Set();
     for (const block of blocks) {
         if (blockNames.has(block.name)) {
@@ -41,11 +35,27 @@ function validateDocumentStructure(schemas, blocks, blockAnchors) {
                 throw new Error(`Duplicate input name in block ${block.name}: ${input.name}`);
             }
             inputNames.add(input.name);
-            if (input.schema && !schemaNames.has(input.schema)) {
-                throw new Error(`Unknown schema ${input.schema} referenced by input ${input.name}`);
+        }
+        for (const operation of block.reads) {
+            if (!operation.name && !(0, block_1.isStreamAccept)(operation.accept)) {
+                throw new Error(`Read operations must declare a name unless they accept text/event-stream: ${operation.id}`);
+            }
+            if ((0, block_1.isStreamAccept)(operation.accept) && operation.name) {
+                throw new Error(`Stream read operations must not declare a name: ${operation.id}`);
+            }
+            if (operation.name) {
+                if (operationNames.has(operation.name)) {
+                    throw new Error(`Duplicate operation name in block ${block.name}: ${operation.name}`);
+                }
+                operationNames.add(operation.name);
+            }
+            for (const inputName of operation.inputs) {
+                if (!inputNames.has(inputName)) {
+                    throw new Error(`Unknown input ${inputName} referenced by ${operation.id}`);
+                }
             }
         }
-        for (const operation of [...block.reads, ...block.writes]) {
+        for (const operation of block.writes) {
             if (operationNames.has(operation.name)) {
                 throw new Error(`Duplicate operation name in block ${block.name}: ${operation.name}`);
             }

package/dist/core/utils/html.d.ts

@@ -0,0 +1,6 @@
+export declare function escapeHtml(value: string): string;
+export declare function escapeRegExp(value: string): string;
+export declare const MAX_INPUT_LENGTH = 10000;
+export declare const MAX_IDENTIFIER_LENGTH = 256;
+export declare function validateInputLength(value: string, maxLength?: number): void;
+export declare function trimTrailingBlankLines(value: string): string;

package/dist/core/utils/html.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_IDENTIFIER_LENGTH = exports.MAX_INPUT_LENGTH = void 0;
+exports.escapeHtml = escapeHtml;
+exports.escapeRegExp = escapeRegExp;
+exports.validateInputLength = validateInputLength;
+exports.trimTrailingBlankLines = trimTrailingBlankLines;
+function escapeHtml(value) {
+    return value
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#39;");
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+exports.MAX_INPUT_LENGTH = 10000;
+exports.MAX_IDENTIFIER_LENGTH = 256;
+function validateInputLength(value, maxLength = exports.MAX_INPUT_LENGTH) {
+    if (value.length > maxLength) {
+        throw new Error(`Input exceeds maximum length of ${maxLength} characters`);
+    }
+}
+function trimTrailingBlankLines(value) {
+    return value.replace(/\n+$/u, "\n");
+}

package/dist/core/utils/index.d.ts

@@ -0,0 +1,2 @@
+export { escapeHtml, escapeRegExp, validateInputLength, trimTrailingBlankLines, MAX_INPUT_LENGTH, MAX_IDENTIFIER_LENGTH, } from "./html";
+export { createLogger, type Logger, type LogLevel, type CreateLoggerOptions } from "./logger";

package/dist/core/utils/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogger = exports.MAX_IDENTIFIER_LENGTH = exports.MAX_INPUT_LENGTH = exports.trimTrailingBlankLines = exports.validateInputLength = exports.escapeRegExp = exports.escapeHtml = void 0;
+var html_1 = require("./html");
+Object.defineProperty(exports, "escapeHtml", { enumerable: true, get: function () { return html_1.escapeHtml; } });
+Object.defineProperty(exports, "escapeRegExp", { enumerable: true, get: function () { return html_1.escapeRegExp; } });
+Object.defineProperty(exports, "validateInputLength", { enumerable: true, get: function () { return html_1.validateInputLength; } });
+Object.defineProperty(exports, "trimTrailingBlankLines", { enumerable: true, get: function () { return html_1.trimTrailingBlankLines; } });
+Object.defineProperty(exports, "MAX_INPUT_LENGTH", { enumerable: true, get: function () { return html_1.MAX_INPUT_LENGTH; } });
+Object.defineProperty(exports, "MAX_IDENTIFIER_LENGTH", { enumerable: true, get: function () { return html_1.MAX_IDENTIFIER_LENGTH; } });
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "createLogger", { enumerable: true, get: function () { return logger_1.createLogger; } });

package/dist/core/utils/logger.d.ts

@@ -0,0 +1,12 @@
+export type LogLevel = "debug" | "info" | "warn" | "error";
+export interface Logger {
+    debug(message: string, context?: Record<string, unknown>): void;
+    info(message: string, context?: Record<string, unknown>): void;
+    warn(message: string, context?: Record<string, unknown>): void;
+    error(message: string, context?: Record<string, unknown>): void;
+}
+export interface CreateLoggerOptions {
+    level?: LogLevel;
+    prefix?: string;
+}
+export declare function createLogger(options?: CreateLoggerOptions): Logger;

package/dist/core/utils/logger.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogger = createLogger;
+const LOG_LEVELS = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+};
+function formatTimestamp() {
+    return new Date().toISOString();
+}
+function formatMessage(level, prefix, message, context) {
+    const timestamp = formatTimestamp();
+    const prefixPart = prefix ? `[${prefix}] ` : "";
+    const contextPart = context ? ` ${JSON.stringify(context)}` : "";
+    return `${timestamp} ${prefixPart}${level.toUpperCase()}: ${message}${contextPart}`;
+}
+function createLogger(options = {}) {
+    const level = options.level ?? "info";
+    const prefix = options.prefix;
+    const levelNumber = LOG_LEVELS[level];
+    return {
+        debug(message, context) {
+            if (levelNumber <= LOG_LEVELS.debug) {
+                console.debug(formatMessage("debug", prefix, message, context));
+            }
+        },
+        info(message, context) {
+            if (levelNumber <= LOG_LEVELS.info) {
+                console.info(formatMessage("info", prefix, message, context));
+            }
+        },
+        warn(message, context) {
+            if (levelNumber <= LOG_LEVELS.warn) {
+                console.warn(formatMessage("warn", prefix, message, context));
+            }
+        },
+        error(message, context) {
+            if (levelNumber <= LOG_LEVELS.error) {
+                console.error(formatMessage("error", prefix, message, context));
+            }
+        },
+    };
+}

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

@@ -6,6 +6,7 @@ export interface CreateFrameworkAppOptions {
     actions?: Record<string, ActionHandler<{
         inputs: Record<string, unknown>;
     }>>;
+    errorFragments?: import("./hosted-app").CreateHostedAppOptions["errorFragments"];
     mode?: "dev" | "start";
     devState?: unknown;
 }

package/dist/framework/create-framework-app.js

@@ -7,5 +7,6 @@ function createFrameworkApp(options) {
         rootDir: options.rootDir,
         config: options.config,
         actions: options.actions,
+        errorFragments: options.errorFragments,
     });
 }