@jxsuite/compiler 0.23.2 → 0.25.0

package/src/targets/{compile-markdown.js → compile-markdown.ts}

@@ -9,12 +9,19 @@
 import { unified } from "unified";
 import remarkStringify from "remark-stringify";
 import remarkGfm from "remark-gfm";
-import { buildInitialScope, evaluateStaticTemplate, isTemplateString } from "../shared.js";
+import { buildInitialScope, evaluateStaticTemplate, isTemplateString } from "../shared.ts";
+import type {
+  JxElement,
+  JxDocument,
+  JxStateDefinition,
+  JxMutableNode,
+} from "@jxsuite/schema/types";
+import type { MdastNode } from "@jxsuite/parser/types";
 
 // ─── Tag classification ────────────────────────────────────────────────────
 
 /** Tags that map directly to mdast node types. */
-const TAG_MDAST_MAP = /** @type {Record<string, string>} */ ({
+const TAG_MDAST_MAP = {
   h1: "heading",
   h2: "heading",
   h3: "heading",
@@ -41,7 +48,7 @@ const TAG_MDAST_MAP = /** @type {Record<string, string>} */ ({
   tr: "tableRow",
   th: "tableCell",
   td: "tableCell",
-});
+} as Record<string, string>;
 
 /** Wrapper tags that should be unwrapped — their children are promoted. */
 const WRAPPER_TAGS = new Set([
@@ -70,7 +77,11 @@ const WRAPPER_TAGS = new Set([
  * @param {Record<string, unknown> | null} [scope] - Current resolution scope
  * @returns {MdastNode[]}
  */
-function nodeToMdast(node, componentDefs, scope) {
+function nodeToMdast(
+  node: JxElement | string,
+  componentDefs: Map<string, JxElement>,
+  scope?: Record<string, unknown> | null,
+): MdastNode[] {
   // Bare text
   if (typeof node === "string") {
     return node.trim() ? [{ type: "text", value: node }] : [];
@@ -154,7 +165,7 @@ function nodeToMdast(node, componentDefs, scope) {
 
     case "link": {
       const href = String(node.attributes?.href ?? "");
-      const title = /** @type {string | null} */ (node.attributes?.title ?? null);
+      const title = (node.attributes?.title as string | null) ?? null;
       const children =
         text != null
           ? [{ type: "text", value: text }]
@@ -165,7 +176,7 @@ function nodeToMdast(node, componentDefs, scope) {
     case "image": {
       const src = String(node.attributes?.src ?? "");
       const alt = String(node.attributes?.alt ?? "");
-      const title = /** @type {string | null} */ (node.attributes?.title ?? null);
+      const title = (node.attributes?.title as string | null) ?? null;
       return [{ type: "image", url: src, alt, title }];
     }
 
@@ -199,16 +210,11 @@ function nodeToMdast(node, componentDefs, scope) {
     case "code": {
       // pre > code → fenced code block
       const codeChild = Array.isArray(node.children)
-        ? node.children.find(
-            (/** @type {JxElement | string} */ c) =>
-              /** @type {JxMutableNode} */ (c)?.tagName === "code",
-          )
+        ? node.children.find((c: JxElement | string) => (c as JxMutableNode)?.tagName === "code")
         : null;
-      const value = /** @type {JxElement | undefined} */ (codeChild)?.textContent ?? text ?? "";
-      const lang = /** @type {JxElement | undefined} */ (codeChild)?.className?.replace(
-        "language-",
-        "",
-      ) ?? null;
+      const value = (codeChild as JxElement | undefined)?.textContent ?? text ?? "";
+      const lang =
+        (codeChild as JxElement | undefined)?.className?.replace("language-", "") ?? null;
       return [{ type: "code", lang, value }];
     }
 
@@ -247,7 +253,7 @@ function nodeToMdast(node, componentDefs, scope) {
  * @param {string} type
  * @returns {boolean}
  */
-function isInlineType(type) {
+function isInlineType(type: string) {
   return ["text", "emphasis", "strong", "delete", "inlineCode", "link", "image", "break"].includes(
     type,
   );
@@ -261,16 +267,18 @@ function isInlineType(type) {
  * @param {Record<string, unknown> | null} [scope]
  * @returns {MdastNode[]}
  */
-function convertChildren(node, componentDefs, scope) {
+function convertChildren(
+  node: JxElement,
+  componentDefs: Map<string, JxElement>,
+  scope?: Record<string, unknown> | null,
+): MdastNode[] {
   if (node.textContent != null) {
     const text = resolveText(node.textContent, scope);
     if (text) return [{ type: "text", value: text }];
     return [];
   }
   if (!Array.isArray(node.children)) return [];
-  return node.children.flatMap((/** @type {JxElement | string} */ c) =>
-    nodeToMdast(c, componentDefs, scope),
-  );
+  return node.children.flatMap((c: JxElement | string) => nodeToMdast(c, componentDefs, scope));
 }
 
 /**
@@ -281,16 +289,18 @@ function convertChildren(node, componentDefs, scope) {
  * @param {Record<string, unknown> | null} [scope]
  * @returns {MdastNode[]}
  */
-function convertChildrenInline(node, componentDefs, scope) {
+function convertChildrenInline(
+  node: JxElement,
+  componentDefs: Map<string, JxElement>,
+  scope?: Record<string, unknown> | null,
+): MdastNode[] {
   if (node.textContent != null) {
     const text = resolveText(node.textContent, scope);
     if (text) return [{ type: "text", value: text }];
     return [];
   }
   if (!Array.isArray(node.children)) return [];
-  return node.children.flatMap((/** @type {JxElement | string} */ c) =>
-    nodeToMdast(c, componentDefs, scope),
-  );
+  return node.children.flatMap((c: JxElement | string) => nodeToMdast(c, componentDefs, scope));
 }
 
 // ─── Component inlining ─────────────────────────────────────────────────────
@@ -303,7 +313,11 @@ function convertChildrenInline(node, componentDefs, scope) {
  * @param {Map<string, JxElement>} componentDefs
  * @returns {MdastNode[]}
  */
-function inlineComponent(node, tag, componentDefs) {
+function inlineComponent(
+  node: JxElement,
+  tag: string,
+  componentDefs: Map<string, JxElement>,
+): MdastNode[] {
   const def = componentDefs.get(tag);
   if (!def) {
     // No definition — unwrap any children the instance has
@@ -324,10 +338,10 @@ function inlineComponent(node, tag, componentDefs) {
       ) {
         stateDefs[key] = { ...existing, default: value };
       } else {
-        stateDefs[key] = /** @type {JxStateDefinition} */ (value);
+        stateDefs[key] = value as JxStateDefinition;
       }
     } else {
-      stateDefs[key] = /** @type {JxStateDefinition} */ (value);
+      stateDefs[key] = value as JxStateDefinition;
     }
   }
 
@@ -341,13 +355,10 @@ function inlineComponent(node, tag, componentDefs) {
 
   // Convert to mdast, passing instance's own children as potential slot content
   const instanceChildren = node.children;
-  return resolved.flatMap((/** @type {JxElement | string} */ child) => {
+  return resolved.flatMap((child: JxElement | string): MdastNode[] => {
     // Replace slot elements with instance children
-    if (
-      /** @type {JxMutableNode} */ (child)?.tagName === "slot" &&
-      Array.isArray(instanceChildren)
-    ) {
-      return instanceChildren.flatMap((/** @type {JxElement | string} */ c) =>
+    if (typeof child !== "string" && child?.tagName === "slot" && Array.isArray(instanceChildren)) {
+      return instanceChildren.flatMap((c: JxElement | string): MdastNode[] =>
         nodeToMdast(c, componentDefs),
       );
     }
@@ -362,9 +373,9 @@ function inlineComponent(node, tag, componentDefs) {
  * @param {Record<string, unknown>} scope
  * @returns {(JxElement | string)[]}
  */
-function deepResolve(nodes, scope) {
+function deepResolve(nodes: (JxElement | string)[], scope: Record<string, unknown>) {
   if (!Array.isArray(nodes)) return [];
-  return nodes.map((/** @type {JxElement | string} */ node) => resolveNode(node, scope));
+  return nodes.map((node: JxElement | string) => resolveNode(node, scope));
 }
 
 /**
@@ -374,7 +385,7 @@ function deepResolve(nodes, scope) {
  * @param {Record<string, unknown>} scope
  * @returns {JxElement | string}
  */
-function resolveNode(node, scope) {
+function resolveNode(node: JxElement | string, scope: Record<string, unknown>) {
   if (typeof node === "string") {
     return isTemplateString(node) ? String(evaluateStaticTemplate(node, scope) ?? node) : node;
   }
@@ -415,18 +426,22 @@ function resolveNode(node, scope) {
  * @param {Record<string, unknown> | null} [scope]
  * @returns {MdastNode[]}
  */
-function expandArray(arrayDef, componentDefs, scope) {
-  const itemsRef = /** @type {JxMutableNode} */ (arrayDef).items?.$ref;
+function expandArray(
+  arrayDef: JxElement,
+  componentDefs: Map<string, JxElement>,
+  scope?: Record<string, unknown> | null,
+): MdastNode[] {
+  const itemsRef = (arrayDef as JxMutableNode).items?.$ref;
   if (!itemsRef || !scope) return [];
 
   // Resolve the items array from scope
   const items = resolveRef(itemsRef, scope);
   if (!Array.isArray(items)) return [];
 
-  const mapTemplate = /** @type {JxMutableNode} */ (arrayDef).map;
+  const mapTemplate = (arrayDef as JxMutableNode).map;
   if (!mapTemplate) return [];
 
-  return items.flatMap((/** @type {JxMutableNode} */ item, /** @type {number} */ index) => {
+  return items.flatMap((item: JxMutableNode, index: number): MdastNode[] => {
     // Create a scope with $map values
     const mapScope = Object.create(scope);
     mapScope.item = item;
@@ -434,7 +449,7 @@ function expandArray(arrayDef, componentDefs, scope) {
 
     // Resolve the map template with $map refs
     const resolved = resolveMapNode(mapTemplate, item);
-    return nodeToMdast(resolved, componentDefs, scope);
+    return nodeToMdast(resolved as JxElement | string, componentDefs, scope);
   });
 }
 
@@ -445,7 +460,7 @@ function expandArray(arrayDef, componentDefs, scope) {
  * @param {Record<string, unknown>} item
  * @returns {any}
  */
-function resolveMapNode(node, item) {
+function resolveMapNode(node: JxMutableNode, item: Record<string, unknown>) {
   if (typeof node === "string") return node;
   if (!node || typeof node !== "object") return node;
 
@@ -453,8 +468,8 @@ function resolveMapNode(node, item) {
 
   // Resolve $ref values
   for (const [key, value] of Object.entries(result)) {
-    if (value && typeof value === "object" && /** @type {JxMutableNode} */ (value).$ref) {
-      const ref = /** @type {string} */ (/** @type {JxMutableNode} */ (value).$ref);
+    if (value && typeof value === "object" && (value as JxMutableNode).$ref) {
+      const ref = (value as JxMutableNode).$ref as string;
       if (ref.startsWith("$map/")) {
         const path = ref.slice("$map/".length);
         result[key] = resolvePath(
@@ -470,12 +485,14 @@ function resolveMapNode(node, item) {
   }
 
   if (typeof result.textContent === "string" && result.textContent.startsWith("$map/")) {
-    result.textContent = resolvePath(item, result.textContent.slice("$map/".length));
+    result.textContent = resolvePath(item, result.textContent.slice("$map/".length)) as unknown as
+      | string
+      | null;
   }
 
   if (Array.isArray(result.children)) {
     result.children = result.children.map((c) =>
-      resolveMapNode(/** @type {JxMutableNode} */ (/** @type {unknown} */ (c)), item),
+      resolveMapNode(c as unknown as JxMutableNode, item),
     );
   }
 
@@ -489,9 +506,9 @@ function resolveMapNode(node, item) {
  * @param {string} path
  * @returns {any}
  */
-function resolvePath(obj, path) {
+function resolvePath(obj: unknown, path: string) {
   const parts = path.split(/[/.]/);
-  let current = /** @type {JxMutableNode} */ (obj);
+  let current = obj as JxMutableNode;
   for (const part of parts) {
     if (current == null) return undefined;
     current = current[part];
@@ -506,7 +523,7 @@ function resolvePath(obj, path) {
  * @param {Record<string, unknown>} scope
  * @returns {unknown}
  */
-function resolveRef(ref, scope) {
+function resolveRef(ref: string, scope: Record<string, unknown>) {
   if (ref.startsWith("#/state/")) {
     return resolvePath(scope, ref.slice("#/state/".length));
   }
@@ -523,7 +540,11 @@ function resolveRef(ref, scope) {
  * @param {Record<string, unknown> | null} [scope]
  * @returns {MdastNode[]}
  */
-function convertTable(node, componentDefs, scope) {
+function convertTable(
+  node: JxElement,
+  componentDefs: Map<string, JxElement>,
+  scope?: Record<string, unknown> | null,
+) {
   // Flatten thead/tbody wrappers to get rows
   const rows = convertChildren(node, componentDefs, scope).filter((c) => c.type === "tableRow");
   if (rows.length === 0) return [];
@@ -539,7 +560,7 @@ function convertTable(node, componentDefs, scope) {
  * @param {Record<string, unknown> | null} [scope]
  * @returns {string | null}
  */
-function resolveText(value, scope) {
+function resolveText(value: unknown, scope?: Record<string, unknown> | null) {
   if (value == null) return null;
   if (typeof value === "string") {
     if (scope && isTemplateString(value)) {
@@ -560,9 +581,8 @@ function resolveText(value, scope) {
  * @param {string} html
  * @returns {MdastNode[]}
  */
-function htmlToMdast(html) {
-  /** @type {MdastNode[]} */
-  const nodes = [];
+function htmlToMdast(html: string) {
+  const nodes: MdastNode[] = [];
 
   // Simple top-level block parser
   const parts = splitHtmlBlocks(html);
@@ -582,9 +602,8 @@ function htmlToMdast(html) {
  * @param {string} html
  * @returns {string[]}
  */
-function splitHtmlBlocks(html) {
-  /** @type {string[]} */
-  const blocks = [];
+function splitHtmlBlocks(html: string) {
+  const blocks: string[] = [];
   const trimmed = html.trim();
 
   // Simple regex: split on top-level block boundaries
@@ -615,7 +634,7 @@ function splitHtmlBlocks(html) {
  * @param {string} html
  * @returns {MdastNode[] | null}
  */
-function parseHtmlElement(html) {
+function parseHtmlElement(html: string) {
   // Heading
   const hMatch = html.match(/^<(h[1-6])(?:\s[^>]*)?>(.+?)<\/\1>$/is);
   if (hMatch) {
@@ -700,9 +719,8 @@ function parseHtmlElement(html) {
  * @param {string} html
  * @returns {MdastNode[]}
  */
-function parseInlineHtml(html) {
-  /** @type {MdastNode[]} */
-  const nodes = [];
+function parseInlineHtml(html: string) {
+  const nodes: MdastNode[] = [];
   let pos = 0;
 
   while (pos < html.length) {
@@ -803,7 +821,7 @@ function parseInlineHtml(html) {
  * @param {string} tag - Tag name to match
  * @returns {number} Position of the matching closing tag, or -1
  */
-function findMatchingClose(html, start, tag) {
+function findMatchingClose(html: string, start: number, tag: string) {
   let depth = 1;
   const openRe = new RegExp(`<${tag}[\\s>]`, "gi");
   const closeRe = new RegExp(`</${tag}>`, "gi");
@@ -834,9 +852,8 @@ function findMatchingClose(html, start, tag) {
  * @param {string} html
  * @returns {MdastNode[]}
  */
-function parseListItems(html) {
-  /** @type {MdastNode[]} */
-  const items = [];
+function parseListItems(html: string) {
+  const items: MdastNode[] = [];
   const liPattern = /<li(?:\s[^>]*)?>([\s\S]*?)<\/li>/gi;
   let m;
   while ((m = liPattern.exec(html)) !== null) {
@@ -856,15 +873,13 @@ function parseListItems(html) {
  * @param {string} html
  * @returns {MdastNode[]}
  */
-function parseHtmlTable(html) {
-  /** @type {MdastNode[]} */
-  const rows = [];
+function parseHtmlTable(html: string) {
+  const rows: MdastNode[] = [];
   const trPattern = /<tr(?:\s[^>]*)?>([\s\S]*?)<\/tr>/gi;
   let m;
   while ((m = trPattern.exec(html)) !== null) {
     const cellPattern = /<(?:th|td)(?:\s[^>]*)?>([\s\S]*?)<\/(?:th|td)>/gi;
-    /** @type {MdastNode[]} */
-    const cells = [];
+    const cells: MdastNode[] = [];
     let c;
     while ((c = cellPattern.exec(m[1])) !== null) {
       cells.push({ type: "tableCell", children: parseInlineHtml(c[1]) });
@@ -881,7 +896,7 @@ function parseHtmlTable(html) {
  * @param {string} html
  * @returns {string}
  */
-function stripHtmlTags(html) {
+function stripHtmlTags(html: string) {
   return html.replace(/<[^>]+>/g, "");
 }
 
@@ -891,7 +906,7 @@ function stripHtmlTags(html) {
  * @param {string} str
  * @returns {string}
  */
-function decodeHtmlEntities(str) {
+function decodeHtmlEntities(str: string) {
   return str
     .replace(/&amp;/g, "&")
     .replace(/&lt;/g, "<")
@@ -911,7 +926,10 @@ function decodeHtmlEntities(str) {
  * @param {Map<string, JxElement>} [componentDefs] - Component definitions for inlining
  * @returns {{ content: string }}
  */
-export function compileMarkdown(doc, componentDefs = new Map()) {
+export function compileMarkdown(
+  doc: JxDocument,
+  componentDefs: Map<string, JxElement> = new Map(),
+) {
   if (!Array.isArray(doc.children) || doc.children.length === 0) {
     return { content: "" };
   }
@@ -920,15 +938,13 @@ export function compileMarkdown(doc, componentDefs = new Map()) {
   const scope = doc.state ? buildInitialScope(doc.state, null) : null;
 
   // Convert to mdast
-  const mdastChildren = doc.children.flatMap((/** @type {JxElement | string} */ child) =>
+  const mdastChildren = doc.children.flatMap((child: JxElement | string) =>
     nodeToMdast(child, componentDefs, scope),
   );
 
   // Clean up: ensure block-level structure (no bare inline nodes at root)
-  /** @type {MdastNode[]} */
-  const cleaned = [];
-  /** @type {MdastNode[]} */
-  let inlineBuf = [];
+  const cleaned: MdastNode[] = [];
+  let inlineBuf: MdastNode[] = [];
 
   const flushInline = () => {
     if (inlineBuf.length > 0) {
@@ -947,9 +963,7 @@ export function compileMarkdown(doc, componentDefs = new Map()) {
   }
   flushInline();
 
-  const mdast = /** @type {import("mdast").Root} */ (
-    /** @type {unknown} */ ({ type: "root", children: cleaned })
-  );
+  const mdast = { type: "root", children: cleaned } as unknown as import("mdast").Root;
 
   const md = unified()
     .use(remarkGfm)

package/src/targets/{compile-server.js → compile-server.ts}

@@ -6,7 +6,8 @@
  */
 
 import $RefParser from "@apidevtools/json-schema-ref-parser";
-import { collectServerEntries } from "../shared.js";
+import { collectServerEntries } from "../shared.ts";
+import type { JxElement } from "@jxsuite/schema/types";
 
 /**
  * Compile a Jx document to a Hono server handler file. The handler exposes each `timing: "server"`
@@ -22,9 +23,14 @@ import { collectServerEntries } from "../shared.js";
  * @param {string} [opts.baseUrl] - Base path for server endpoints. Default is `'/_jx/server'`
  * @returns {Promise<string | null>} Hono server handler source string, or null
  */
-export async function compileServer(sourcePath, opts = {}) {
+export async function compileServer(
+  sourcePath: string | object,
+  opts: {
+    baseUrl?: string;
+  } = {},
+) {
   const { baseUrl = "/_jx/server" } = opts;
-  const doc = /** @type {JxElement} */ (await $RefParser.dereference(sourcePath));
+  const doc = (await $RefParser.dereference(sourcePath)) as JxElement;
   const entries = collectServerEntries(doc);
   if (entries.length === 0) return null;
 
@@ -58,7 +64,13 @@ export default app
  * @param {string | null} [opts.adapter] - Deployment adapter: `"cloudflare"`, `"node"`, `"bun"`
  * @returns {string | null} Complete worker/server source string, or null
  */
-export function compileSiteServer(entries, opts = {}) {
+export function compileSiteServer(
+  entries: { exportName: string; src: string }[],
+  opts: {
+    baseUrl?: string;
+    adapter?: string | null;
+  } = {},
+) {
   const { baseUrl = "/_jx/server", adapter = null } = opts;
   if (entries.length === 0 && !adapter) return null;
 
@@ -85,7 +97,7 @@ export default app
 }
 
 /** @param {string} exportName @param {string} baseUrl */
-function buildRoute(exportName, baseUrl) {
+function buildRoute(exportName: string, baseUrl: string) {
   return `
 app.post('${baseUrl}/${exportName}', async (c) => {
   const args = await c.req.json().catch(() => ({}))
@@ -107,7 +119,12 @@ app.post('${baseUrl}/${exportName}', async (c) => {
  * @returns {Map<string, string>} Map of output path → source (e.g.
  *   `"functions/_jx/server/sendEmail.js"` → source)
  */
-export function compilePagesFunctions(entries, opts = {}) {
+export function compilePagesFunctions(
+  entries: { exportName: string; src: string }[],
+  opts: {
+    baseUrl?: string;
+  } = {},
+) {
   const { baseUrl = "/_jx/server" } = opts;
   const files = new Map();
 

package/src/targets/{compile-static.js → compile-static.ts}

@@ -12,8 +12,9 @@ import {
   buildAttrs,
   compileStyles,
   escapeHtml,
-} from "../shared.js";
-import { emitElementModule } from "./compile-element.js";
+} from "../shared.ts";
+import { emitElementModule } from "./compile-element.ts";
+import type { JxStyle, JxMutableNode } from "@jxsuite/schema/types";
 
 /**
  * Compile a static document to HTML, with dynamic subtrees as islands.
@@ -23,17 +24,19 @@ import { emitElementModule } from "./compile-element.js";
  * @param {Record<string, unknown>} opts
  * @returns {{ html: string; files: { path: string; content: string; tagName: string }[] }}
  */
-export function compileStaticPage(raw, opts) {
-  const { title, reactivitySrc, litHtmlSrc } = /** @type {JxMutableNode} */ (opts);
+export function compileStaticPage(
+  raw: JxMutableNode | Record<string, any>,
+  opts: Record<string, unknown>,
+) {
+  const { title, reactivitySrc, litHtmlSrc } = opts as JxMutableNode;
 
   const rootContext = createCompileContext(raw, null, raw.state ?? {}, raw.$media ?? {});
   const styleBlock = compileStyles(
     raw,
     raw.$media ?? {},
-    /** @type {JxStyle | null} */ (opts.projectStyle ?? null),
+    (opts.projectStyle ?? null) as JxStyle | null,
   );
-  /** @type {{ def: any; tagName: string; className: string }[]} */
-  const islands = [];
+  const islands: { def: JxMutableNode; tagName: string; className: string }[] = [];
   const bodyContent = compileNode(raw, false, raw, rootContext, islands);
 
   /** @type {{ path: string; content: string; tagName: string }[]} */
@@ -95,7 +98,17 @@ export function compileStaticPage(raw, opts) {
  * @param {{ def: any; tagName: string; className: string }[]} islands
  * @returns {string}
  */
-function compileNode(def, dynamic, raw, context, islands) {
+function compileNode(
+  def: JxMutableNode,
+  dynamic: boolean,
+  raw: JxMutableNode,
+  context: {
+    scope: Record<string, unknown> | null;
+    scopeDefs: Record<string, unknown>;
+    media: Record<string, string>;
+  },
+  islands: { def: JxMutableNode; tagName: string; className: string }[],
+): string {
   // String children are text nodes
   if (typeof def === "string") {
     return escapeHtml(def);
@@ -138,7 +151,16 @@ function compileNode(def, dynamic, raw, context, islands) {
  * @param {{ def: any; tagName: string; className: string }[]} islands
  * @returns {string}
  */
-function buildInnerWithIslands(def, raw, context, islands) {
+function buildInnerWithIslands(
+  def: JxMutableNode,
+  raw: JxMutableNode,
+  context: {
+    scope: Record<string, unknown> | null;
+    scopeDefs: Record<string, unknown>;
+    media: Record<string, string>;
+  },
+  islands: { def: JxMutableNode; tagName: string; className: string }[],
+): string {
   const source = raw ?? def;
 
   if (source.textContent !== undefined) {
@@ -146,19 +168,14 @@ function buildInnerWithIslands(def, raw, context, islands) {
     return value == null ? "" : escapeHtml(String(value));
   }
   if (source.innerHTML)
-    return (
-      /** @type {string} */ (resolveStaticValue(source.innerHTML, context.scope)) ??
-      source.innerHTML
-    );
+    return (resolveStaticValue(source.innerHTML, context.scope) as string) ?? source.innerHTML;
   if (Array.isArray(source.children)) {
     const rawChildren = raw?.children;
     return source.children
-      .map((c, /** @type {number} */ i) => {
-        const child = /** @type {JxMutableNode} */ (/** @type {unknown} */ (c));
+      .map((c, i: number) => {
+        const child = c as unknown as JxMutableNode;
         const childDynamic = isNodeDynamic(child);
-        const childRaw = /** @type {JxMutableNode} */ (
-          /** @type {unknown} */ (rawChildren?.[i] ?? c)
-        );
+        const childRaw = (rawChildren?.[i] ?? c) as JxMutableNode;
         return compileNode(child, childDynamic, childRaw, context, islands);
       })
       .join("\n  ");

package/src/types.ts

@@ -0,0 +1,16 @@
+export interface HeadMergeContext {
+  title?: string;
+  siteName?: string;
+  lang?: string;
+  charset?: string;
+  url?: string;
+  siteUrl?: string;
+  pageUrl?: string;
+}
+
+export interface SiteRoute {
+  urlPattern: string;
+  sourcePath?: string;
+  _pathParams?: Record<string, string>;
+  [key: string]: unknown;
+}