@jxsuite/compiler 0.26.2 → 0.28.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jxsuite/compiler",
-  "version": "0.26.2",
+  "version": "0.28.0",
   "description": "Jx static HTML compiler, island detector, and site builder",
   "license": "MIT",
   "repository": {
@@ -20,6 +20,7 @@
   "exports": {
     ".": "./src/compiler.ts",
     "./content-loader": "./src/site/content-loader.ts",
+    "./format-host": "./src/site/format-host.ts",
     "./context-injection": "./src/site/context-injection.ts",
     "./head-merger": "./src/site/head-merger.ts",
     "./layout-resolver": "./src/site/layout-resolver.ts",
@@ -41,13 +42,10 @@
   },
   "dependencies": {
     "@apidevtools/json-schema-ref-parser": "^15.3.5",
-    "@jxsuite/parser": "^0.26.2",
-    "@jxsuite/runtime": "^0.26.2",
-    "@jxsuite/schema": "^0.26.2",
-    "remark-gfm": "^4.0.1",
-    "remark-stringify": "^11.0.0",
-    "sharp": "^0.34.5",
-    "unified": "^11.0.5"
+    "@jxsuite/parser": "^0.28.0",
+    "@jxsuite/runtime": "^0.28.0",
+    "@jxsuite/schema": "^0.28.0",
+    "sharp": "^0.34.5"
   },
   "devDependencies": {
     "@happy-dom/global-registrator": "^20.10.2",

package/src/compiler.ts

@@ -74,11 +74,19 @@ export async function compile(sourcePath: string | any, opts: Record<string, unk
   let raw;
   if (typeof sourcePath === "string") {
     const source = readFileSync(sourcePath, "utf8");
-    if (sourcePath.endsWith(".md")) {
-      const { transpileJxMarkdown } = await import("@jxsuite/parser/transpile");
-      raw = transpileJxMarkdown(source);
-    } else {
+    if (sourcePath.endsWith(".json")) {
       raw = JSON.parse(source);
+    } else {
+      const { extname } = await import("node:path");
+      const ext = extname(sourcePath).toLowerCase();
+      const registry = (opts as JxMutableNode)
+        .formats as import("@jxsuite/schema/format-registry").FormatRegistry;
+      const entry = registry?.byExtension?.(ext, "parse");
+      if (!entry) {
+        const { unknownFormatError } = await import("./site/format-host.ts");
+        throw unknownFormatError(sourcePath, ext);
+      }
+      raw = await entry.call("parse", source);
     }
   } else {
     raw = sourcePath;
@@ -97,7 +105,12 @@ export async function compile(sourcePath: string | any, opts: Record<string, unk
 
   // Route 1: Fully static → plain HTML/CSS
   if (!isDynamic(raw)) {
-    return compileStaticPage(raw, { title, reactivitySrc, litHtmlSrc, projectStyle });
+    return compileStaticPage(raw, {
+      title,
+      reactivitySrc,
+      litHtmlSrc,
+      projectStyle,
+    });
   }
 
   // Route 2: Custom element tagName (contains hyphen) → lit-html web component
@@ -105,7 +118,11 @@ export async function compile(sourcePath: string | any, opts: Record<string, unk
     const tagName = raw.tagName;
     const className = tagNameToClassName(tagName);
     const moduleContent = emitElementModule(raw, className, []);
-    const moduleFile = { path: `${tagName}.js`, content: moduleContent, tagName };
+    const moduleFile = {
+      path: `${tagName}.js`,
+      content: moduleContent,
+      tagName,
+    };
     const styleBlock = compileStyles(raw, raw.$media ?? {});
 
     const html = `<!DOCTYPE html>
@@ -162,7 +179,7 @@ export async function runCli(src: string, out?: string) {
   }
   if (server && out) {
     const serverOut = out.replace(/(\.[^.]+)?$/, "-server.js");
-    writeFileSync(serverOut, /** @type {string} */ (server), "utf8");
+    writeFileSync(serverOut, /** @type {string} */ server, "utf8");
     console.error(`Server handler written to ${serverOut}`);
   }
 }

package/src/shared.ts

@@ -115,7 +115,7 @@ export function isDynamic(def: JxElement | JxMutableNode | string) {
         continue;
       if (typeof d !== "object" || d === null || Array.isArray(d)) return true;
       if ((d as JxPrototypeDef).$prototype) return true;
-      if ("default" in /** @type {object} */ (d)) return true;
+      if ("default" in /** @type {object} */ d) return true;
       if (isSchemaOnly(d)) continue;
       return true;
     }
@@ -564,7 +564,7 @@ export function compileStyles(
             : key;
           const mProps = toCSSText(val);
           if (mProps) rules.push(`${atRule} { ${selector} { ${mProps} } }`);
-          for (const [sel, sub] of Object.entries(/** @type {Record<string, unknown>} */ (val))) {
+          for (const [sel, sub] of Object.entries(/** @type {Record<string, unknown>} */ val)) {
             if (sub === null || typeof sub !== "object" || Array.isArray(sub)) continue;
             if (sel.startsWith("@")) continue;
             const resolved = sel.startsWith("&")
@@ -663,7 +663,7 @@ function emitNestedElement(
           : key;
       const mProps = toCSSText(val);
       if (mProps) rules.push(`${atRule} { ${selector} { ${mProps} } }`);
-      for (const [sel, sub] of Object.entries(/** @type {Record<string, unknown>} */ (val))) {
+      for (const [sel, sub] of Object.entries(/** @type {Record<string, unknown>} */ val)) {
         if (sub === null || typeof sub !== "object" || Array.isArray(sub)) continue;
         if (sel.startsWith("@")) continue;
         const resolved = sel.startsWith("&")
@@ -744,7 +744,7 @@ export function collectStyles(
         const atBaseProps = toCSSText(val);
         if (atBaseProps) rules.push(`${atRule} { ${selector} { ${atBaseProps} } }`);
         for (const [sel, nestedRules] of Object.entries(
-          /** @type {Record<string, unknown>} */ (val),
+          /** @type {Record<string, unknown>} */ val,
         )) {
           if (nestedRules === null || typeof nestedRules !== "object" || Array.isArray(nestedRules))
             continue;
@@ -764,7 +764,7 @@ export function collectStyles(
             : `${selector} ${prop}`;
         emitNestedElement(
           resolved,
-          /** @type {Record<string, unknown>} */ (val),
+          /** @type {Record<string, unknown>} */ val,
           rules,
           mediaQueries,
         );
@@ -889,7 +889,11 @@ function _walkServerEntries(
         entry.$export &&
         !entry.$prototype
       ) {
-        entries.set(entry.$export, { key, exportName: entry.$export, src: entry.$src });
+        entries.set(entry.$export, {
+          key,
+          exportName: entry.$export,
+          src: entry.$src,
+        });
       }
     }
   }
@@ -995,7 +999,10 @@ export function preRenderComponentHtml(
           !Array.isArray(existing) &&
           "default" in existing
         ) {
-          stateDefs[key] = { .../** @type {JxStateObject} */ (existing), default: value };
+          stateDefs[key] = {
+            .../** @type {JxStateObject} */ existing,
+            default: value,
+          };
         } else {
           stateDefs[key] = value as JxStateDefinition;
         }

package/src/site/content-loader.ts

@@ -1,150 +1,31 @@
 /**
- * Content-loader.js — Content type loader
+ * Content-loader.js — Format-agnostic content type loader
  *
- * Loads content types defined in project.json's `contentTypes` key. Supports Markdown (.md), JSON
- * (.json), and CSV (.csv) source files or remote URLs.
+ * Loads content types defined in project.json's `contentTypes` key. JSON sources are handled
+ * natively (Jx IS JSON); every other format dispatches through the format registry built from the
+ * project's imports map — the class's `discover` capability lists entry files and its `load`
+ * capability parses each into ContentLoaderEntry[].
  *
- * Phase 2 implementation of site-architecture spec §6.
+ * There are no implicit format defaults: a content type either names an imported format class via
+ * its `format` key, or its source extension must match a registered format. Remote http(s) sources
+ * require an explicit `format` whose class declares `format.remote: true`.
  *
  * @module content-loader
  */
 
 import { readFileSync, readdirSync, existsSync } from "node:fs";
 import { resolve, basename, extname } from "node:path";
+import { buildProjectFormatRegistry, unknownFormatError } from "./format-host.ts";
+import type { FormatRegistry, FormatEntry } from "@jxsuite/schema/format-registry";
 import type {
   ProjectConfig,
   ContentTypeDef,
   ContentTypeSchema,
   JxMutableNode,
 } from "@jxsuite/schema/types";
-import type { MarkdownFileResult, ContentLoaderEntry } from "@jxsuite/parser/types";
+import type { ContentLoaderEntry } from "@jxsuite/parser/types";
 
-// ─── CSV Parser (minimal, spec-compliant) ─────────────────────────────────────
-
-/**
- * Parse a CSV string into an array of objects using the first row as headers. Handles quoted fields
- * with commas and newlines.
- *
- * @param {string} csv - Raw CSV text
- * @returns {Record<string, string>[]} Array of row objects
- */
-function parseCSV(csv: string) {
-  const rows: Record<string, string>[] = [];
-  let current = "";
-  let inQuotes = false;
-  const lines: string[] = [];
-
-  // Split into rows respecting quoted newlines (preserve raw characters)
-  for (let i = 0; i < csv.length; i++) {
-    const ch = csv[i];
-    if (ch === '"') {
-      current += ch;
-      if (inQuotes && csv[i + 1] === '"') {
-        current += csv[i + 1];
-        i++;
-      } else {
-        inQuotes = !inQuotes;
-      }
-    } else if ((ch === "\n" || (ch === "\r" && csv[i + 1] === "\n")) && !inQuotes) {
-      lines.push(current);
-      current = "";
-      if (ch === "\r") i++;
-    } else {
-      current += ch;
-    }
-  }
-  if (current.trim()) lines.push(current);
-
-  if (lines.length === 0) return [];
-
-  /** @param {string} line */
-  const parseRow = (line: string) => {
-    const fields: string[] = [];
-    let field = "";
-    let q = false;
-    for (let i = 0; i < line.length; i++) {
-      const ch = line[i];
-      if (ch === '"') {
-        if (q && line[i + 1] === '"') {
-          field += '"';
-          i++;
-        } else {
-          q = !q;
-        }
-      } else if (ch === "," && !q) {
-        fields.push(field);
-        field = "";
-      } else {
-        field += ch;
-      }
-    }
-    fields.push(field);
-    return fields;
-  };
-
-  const headers = parseRow(lines[0]);
-  for (let i = 1; i < lines.length; i++) {
-    const fields = parseRow(lines[i]);
-    const obj: Record<string, string> = {};
-    for (let j = 0; j < headers.length; j++) {
-      obj[headers[j].trim()] = fields[j]?.trim() ?? "";
-    }
-    rows.push(obj);
-  }
-  return rows;
-}
-
-// ─── Markdown loader ──────────────────────────────────────────────────────────
-
-/**
- * @type {{
- *   MarkdownFile: new (opts: Record<string, unknown>) => { resolve(): MarkdownFileResult };
- * } | null}
- */
-let _mdModule: {
-  MarkdownFile: new (opts: Record<string, unknown>) => { resolve(): MarkdownFileResult };
-} | null = null;
-
-/**
- * Lazily import @jxsuite/parser for Markdown support. This avoids hard dependency — only loads when
- * MD content types exist.
- *
- * @returns {Promise<{
- *   MarkdownFile: new (opts: Record<string, unknown>) => { resolve(): MarkdownFileResult };
- * }>}
- */
-async function getMarkdownModule() {
-  if (!_mdModule) {
-    _mdModule = (await import("@jxsuite/parser")) as unknown as NonNullable<typeof _mdModule>;
-  }
-  return _mdModule as NonNullable<typeof _mdModule>;
-}
-
-/**
- * Load a markdown file into a ContentEntry. If directiveOptions are provided, they control which
- * custom element directives are available in the markdown.
- *
- * @param {string} filePath - Absolute path to .md file
- * @param {unknown} [directiveOptions] - Options for the MarkdownDirective plugin
- * @returns {Promise<ContentLoaderEntry>} ContentEntry shape
- */
-async function loadMarkdownEntry(filePath: string, directiveOptions?: unknown) {
-  const { MarkdownFile } = await getMarkdownModule();
-  const file = new MarkdownFile({ src: filePath, directiveOptions });
-  const result = file.resolve();
-  const _meta: ContentLoaderEntry["_meta"] = {};
-  if (result.$excerpt != null) _meta.excerpt = result.$excerpt;
-  if (result.$toc != null) _meta.toc = result.$toc;
-  if (result.$readingTime != null) _meta.readingTime = result.$readingTime;
-  if (result.$wordCount != null) _meta.wordCount = result.$wordCount;
-  return {
-    id: result.slug,
-    data: result.frontmatter,
-    body: readFileSync(filePath, "utf-8"),
-    $children: result.$children,
-    _meta,
-  };
-}
+// ─── JSON loader (the single native built-in format) ─────────────────────────
 
 /**
  * Load a JSON file into ContentEntry(s). If the file is an array, each element is an entry. If it's
@@ -173,58 +54,18 @@ function loadJSONEntries(filePath: string) {
   ];
 }
 
-/**
- * Load a CSV file into ContentEntry(s).
- *
- * @param {string} filePath - Absolute path to .csv file
- * @param {ContentTypeSchema} [schema] - Content type schema (for type coercion)
- * @returns {ContentLoaderEntry[]} Array of ContentEntry shapes
- */
-/**
- * Coerce raw CSV row strings to typed values per the schema. - number: strips currency
- * symbols/commas, returns null for empty cells - boolean: "true" → true, everything else → false -
- * string: trimmed (already done by parseCSV, but defensively applied)
- */
-function coerceCSVRows(
-  rows: Record<string, string>[],
-  schema?: ContentTypeSchema,
-): ContentLoaderEntry[] {
-  return rows.map((row, i) => {
-    const data: Record<string, unknown> = { ...row };
-    if (schema?.properties) {
-      for (const [key, def] of Object.entries(schema.properties)) {
-        if (!(key in data)) continue;
-        if (def.type === "number") {
-          const raw = String(data[key] ?? "").trim();
-          if (raw === "") {
-            data[key] = null;
-          } else {
-            const cleaned = raw.replace(/[$€£¥,\s]/g, "");
-            const n = Number(cleaned);
-            data[key] = isNaN(n) ? null : n;
-          }
-        } else if (def.type === "boolean") {
-          data[key] = data[key] === "true";
-        }
-      }
-    }
-    const id = (data.id as string | undefined) ?? (data.sku as string | undefined) ?? String(i);
-    return { id, data, body: null };
-  });
-}
-
-function loadCSVEntries(filePath: string, schema?: ContentTypeSchema) {
-  const rows = parseCSV(readFileSync(filePath, "utf-8"));
-  return coerceCSVRows(rows, schema);
-}
-
-/** Fetch a remote CSV URL and return ContentLoaderEntry[]. */
-async function loadRemoteCSV(url: string, schema?: ContentTypeSchema) {
-  const response = await fetch(url);
-  if (!response.ok) {
-    throw new Error(`Failed to fetch CSV from ${url}: ${response.status} ${response.statusText}`);
+/** Discover .json entry files for a source (single file or directory). */
+function discoverJSONFiles(resolvedSource: string): string[] {
+  if (extname(resolvedSource)) {
+    return existsSync(resolvedSource) ? [resolvedSource] : [];
+  }
+  try {
+    return readdirSync(resolvedSource, { recursive: true })
+      .filter((f) => String(f).endsWith(".json"))
+      .map((f) => resolve(resolvedSource, String(f)));
+  } catch {
+    return [];
   }
-  return coerceCSVRows(parseCSV(await response.text()), schema);
 }
 
 // ─── Content Config ───────────────────────────────────────────────────────────
@@ -255,18 +96,26 @@ export function loadContentConfig(projectRoot: string, projectConfig?: ProjectCo
  *
  * @param {string} projectRoot - Project root directory
  * @param {ProjectConfig} [projectConfig] - Already-loaded project config
+ * @param {FormatRegistry} [registry] - Pre-built format registry (built from imports if omitted)
  * @returns {Promise<Map<string, ContentLoaderEntry[]>>} Map of content type name → array of
  *   ContentEntry
  */
-export async function loadContentTypes(projectRoot: string, projectConfig?: ProjectConfig) {
+export async function loadContentTypes(
+  projectRoot: string,
+  projectConfig?: ProjectConfig,
+  registry?: FormatRegistry,
+) {
   const result = loadContentConfig(projectRoot, projectConfig);
   if (!result) return new Map();
 
   const { config } = result;
   const contentTypes: Map<string, ContentLoaderEntry[]> = new Map();
+  if (Object.keys(config.contentTypes).length === 0) return contentTypes;
+
+  const formats = registry ?? (await buildProjectFormatRegistry(projectRoot, projectConfig));
 
   for (const [name, contentTypeDef] of Object.entries(config.contentTypes)) {
-    const entries = await loadContentType(name, contentTypeDef, projectRoot);
+    const entries = await loadContentType(name, contentTypeDef, projectRoot, formats);
     contentTypes.set(name, entries);
   }
 
@@ -293,14 +142,20 @@ export function getContentTypeElements(
 }
 
 /**
- * Load a single content type by its definition.
+ * Load a single content type by its definition, dispatching through the format registry.
  *
  * @param {string} name - Content type name
  * @param {ContentTypeDef} contentTypeDef - Content type definition from project.json
  * @param {string} projectRoot - Absolute path to project root directory
+ * @param {FormatRegistry} registry - Format registry built from project imports
  * @returns {Promise<ContentLoaderEntry[]>} Array of ContentEntry
  */
-async function loadContentType(name: string, contentTypeDef: ContentTypeDef, projectRoot: string) {
+async function loadContentType(
+  name: string,
+  contentTypeDef: ContentTypeDef,
+  projectRoot: string,
+  registry: FormatRegistry,
+) {
   const source = contentTypeDef.source;
   if (!source) return [];
   const schema = contentTypeDef.schema;
@@ -316,10 +171,38 @@ async function loadContentType(name: string, contentTypeDef: ContentTypeDef, pro
       }
     : undefined;
 
-  // Remote URL source (e.g. Google Sheets CSV export)
+  // Resolve the format class: explicit `format` (an import name) wins; "json" is native
+  const formatName = contentTypeDef.format;
+  let entry: FormatEntry | undefined;
+  if (formatName && formatName !== "json") {
+    entry = registry.byName(formatName);
+    if (!entry) {
+      throw new Error(
+        `Content type "${name}": format "${formatName}" is not an imported format class. ` +
+          `Add it to project.json imports, e.g. "${formatName}": "@jxsuite/parser/${formatName}.class.json".`,
+      );
+    }
+  }
+
+  // Remote URL source — requires an explicit remote-capable format (no implicit fallback)
   if (source.startsWith("http://") || source.startsWith("https://")) {
+    if (!entry) {
+      throw new Error(
+        `Content type "${name}": remote sources require an explicit "format" naming an ` +
+          `imported format class with "remote": true (e.g. "Csv").`,
+      );
+    }
+    if (!entry.remote) {
+      throw new Error(
+        `Content type "${name}": format "${entry.name}" does not support remote sources ` +
+          `(its format block lacks "remote": true).`,
+      );
+    }
     try {
-      const entries = await loadRemoteCSV(source, schema);
+      const entries = (await entry.call("load", source, {
+        schema,
+        directiveOptions,
+      })) as ContentLoaderEntry[];
       if (schema) validateEntries(entries, schema, name);
       return entries;
     } catch (e) {
@@ -328,38 +211,44 @@ async function loadContentType(name: string, contentTypeDef: ContentTypeDef, pro
     }
   }
 
-  // Resolve source path and discover files
   const resolvedSource = resolve(projectRoot, source).split("\\").join("/");
-  /** @type {string[]} */
-  let files: string[];
-
-  if (extname(source)) {
-    files = existsSync(resolvedSource) ? [resolvedSource] : [];
-  } else {
-    const format = contentTypeDef.format || "md";
-    const ext = `.${format}`;
-    const dir = resolvedSource.endsWith("/") ? resolvedSource : resolvedSource + "/";
-    try {
-      files = readdirSync(dir, { recursive: true })
-        .filter((f) => String(f).endsWith(ext))
-        .map((f) => resolve(dir, String(f)));
-    } catch {
-      files = [];
-    }
+  const ext = extname(source).toLowerCase();
+
+  // JSON — the native built-in
+  if (formatName === "json" || (!entry && ext === ".json")) {
+    const files = discoverJSONFiles(resolvedSource);
+    const entries: ContentLoaderEntry[] = [];
+    for (const filePath of files) entries.push(...loadJSONEntries(filePath));
+    if (schema) validateEntries(entries, schema, name);
+    return entries;
   }
 
-  const entries: ContentLoaderEntry[] = [];
+  // Derive the format from the source extension when no explicit format is named
+  if (!entry && ext) {
+    entry = registry.byExtension(ext, "load");
+  }
+  if (!entry) {
+    throw unknownFormatError(
+      source,
+      ext || `content type "${name}" (directory sources need an explicit "format")`,
+    );
+  }
 
+  // Discover entry files via the class, then load each
+  const files = entry.capabilities.discover
+    ? ((await entry.call("discover", source, {
+        baseDir: projectRoot,
+      })) as string[])
+    : [resolvedSource];
+
+  const entries: ContentLoaderEntry[] = [];
   for (const filePath of files) {
-    const ext = extname(filePath).toLowerCase();
-
-    if (ext === ".md") {
-      entries.push(await loadMarkdownEntry(filePath, directiveOptions));
-    } else if (ext === ".json") {
-      entries.push(...loadJSONEntries(filePath));
-    } else if (ext === ".csv") {
-      entries.push(...loadCSVEntries(filePath, schema));
-    }
+    entries.push(
+      ...((await entry.call("load", filePath, {
+        schema,
+        directiveOptions,
+      })) as ContentLoaderEntry[]),
+    );
   }
 
   // Validate entries against schema if present

package/src/site/context-injection.ts

@@ -98,7 +98,7 @@ export function injectContext(
         ...(doc.$elements as (string | JxElement)[]),
       ]) {
         const key =
-          typeof entry === "string" ? entry : /** @type {{ $ref?: string }} */ (entry)?.$ref;
+          typeof entry === "string" ? entry : /** @type {{ $ref?: string }} */ entry?.$ref;
         if (key && !seen.has(key)) {
           seen.add(key);
           merged.push(entry);

package/src/site/format-host.ts

@@ -0,0 +1,84 @@
+/**
+ * Format-host — node-side FormatHostIO and project registry construction
+ *
+ * Provides the filesystem/module I/O the shared format registry needs to run inside the compiler
+ * (and dev server). Format classes are auto-discovered from the project-level imports map; see
+ * specs/extensions.md.
+ */
+
+import { readFileSync } from "node:fs";
+import { dirname, resolve, isAbsolute, sep } from "node:path";
+import { pathToFileURL } from "node:url";
+import { createRequire } from "node:module";
+import {
+  buildFormatRegistry,
+  type FormatRegistry,
+  type FormatHostIO,
+} from "@jxsuite/schema/format-registry";
+import type { ProjectConfig } from "@jxsuite/schema/types";
+
+export type { FormatRegistry, FormatEntry } from "@jxsuite/schema/format-registry";
+
+/**
+ * Import a class $implementation module by absolute path, tolerating source-vs-built layouts. A
+ * `.class.json` typically declares `"$implementation": "./markdown.js"` next to its TypeScript
+ * source: under Bun the sibling `.ts` resolves directly, while under node the built module lives in
+ * the package's `dist/` directory. Tries, in order: the literal path, src/ → dist/, .js → .ts.
+ *
+ * @param {string} path - Absolute path to the implementation module
+ * @returns {Promise<Record<string, unknown>>}
+ */
+export async function importImplementation(path: string): Promise<Record<string, unknown>> {
+  const candidates = [path];
+  const srcSeg = `${sep}src${sep}`;
+  const distSeg = `${sep}dist${sep}`;
+  if (path.includes(srcSeg)) candidates.push(path.replace(srcSeg, distSeg));
+  if (path.endsWith(".js")) candidates.push(path.slice(0, -3) + ".ts");
+
+  let lastError: unknown;
+  for (const candidate of candidates) {
+    try {
+      return await import(pathToFileURL(candidate).href);
+    } catch (e) {
+      lastError = e;
+    }
+  }
+  throw lastError;
+}
+
+/** Create a node FormatHostIO rooted at a project (bare specifiers resolve via node_modules). */
+export function createNodeFormatIO(projectRoot: string): FormatHostIO {
+  return {
+    loadJson: async (path) => JSON.parse(readFileSync(path, "utf-8")),
+    importModule: (path) => importImplementation(path),
+    resolvePath: (base, ref) => {
+      if (ref.startsWith("./") || ref.startsWith("../")) {
+        return resolve(dirname(base), ref);
+      }
+      if (isAbsolute(ref)) return ref;
+      const require = createRequire(resolve(projectRoot, "package.json"));
+      return require.resolve(ref);
+    },
+  };
+}
+
+/** Build the format registry for a project from its project.json imports map. */
+export async function buildProjectFormatRegistry(
+  projectRoot: string,
+  projectConfig?: ProjectConfig,
+): Promise<FormatRegistry> {
+  return buildFormatRegistry(
+    projectConfig?.imports as Record<string, string> | undefined,
+    createNodeFormatIO(projectRoot),
+    resolve(projectRoot, "project.json"),
+  );
+}
+
+/** Error message for an unregistered non-JSON extension, naming the fix. */
+export function unknownFormatError(path: string, ext: string): Error {
+  return new Error(
+    `No format class imported for "${ext}" (${path}). ` +
+      `Add a format class to project.json imports, e.g. ` +
+      `"Markdown": "@jxsuite/parser/Markdown.class.json".`,
+  );
+}

package/src/site/head-merger.ts

@@ -37,7 +37,10 @@ export function mergeHead(
     { tagName: "meta", attributes: { charset: context.charset ?? "utf-8" } },
     {
       tagName: "meta",
-      attributes: { name: "viewport", content: "width=device-width, initial-scale=1" },
+      attributes: {
+        name: "viewport",
+        content: "width=device-width, initial-scale=1",
+      },
     },
   ];