@openelement/adapter-vite 0.41.0-alpha.1

package/src/head-injection.js

@@ -0,0 +1,248 @@
+/**
+ * @openelement/adapter-vite — Head injection validation & serialization.
+ *
+ * Extracted from index.ts in v0.22 (SOP-004: adapter-vite decomposition).
+ *
+ * Provides:
+ * - assertNoScriptTags() — script tag safety check for head fragments
+ * - validateSafeUrl()    — URL protocol validation against XSS vectors
+ * - buildHeadExtras()    — serialize headFragments, stylesheets, and scripts
+ *                          into a single headExtras string
+ */ import { OpenElementError } from '@openelement/core/errors';
+import { escapeAttr as escapeHtmlAttr } from '@openelement/core';
+import { createLogger } from '@openelement/core/logger';
+// @deno-types="npm:@types/sanitize-html@^2"
+import sanitizeHtml from 'sanitize-html';
+const log = createLogger('adapter-vite:head-injection');
+const SAFE_SCHEMES = [
+  'http',
+  'https',
+  'mailto',
+  'tel',
+  'sms'
+];
+const HEAD_SANITIZE_OPTIONS = {
+  allowedTags: [
+    'base',
+    'link',
+    'meta',
+    'noscript',
+    'style',
+    'title'
+  ],
+  allowedAttributes: {
+    base: [
+      'href',
+      'target'
+    ],
+    link: [
+      'as',
+      'crossorigin',
+      'href',
+      'hreflang',
+      'imagesizes',
+      'imagesrcset',
+      'integrity',
+      'media',
+      'referrerpolicy',
+      'rel',
+      'sizes',
+      'title',
+      'type'
+    ],
+    meta: [
+      'charset',
+      'content',
+      'http-equiv',
+      'name',
+      'property'
+    ],
+    noscript: [],
+    style: [
+      'media',
+      'nonce',
+      'title'
+    ],
+    title: []
+  },
+  allowedSchemes: SAFE_SCHEMES,
+  allowedSchemesByTag: {
+    link: SAFE_SCHEMES,
+    base: [
+      'http',
+      'https'
+    ]
+  },
+  allowedSchemesAppliedToAttributes: [
+    'href',
+    'src',
+    'action',
+    'formaction',
+    'xlink:href'
+  ],
+  allowProtocolRelative: false,
+  allowVulnerableTags: true
+};
+function sanitizeHeadHtml(html, context) {
+  const sanitized = sanitizeHtml(html, HEAD_SANITIZE_OPTIONS);
+  if (sanitized.trim() !== html.trim()) {
+    log.warn(`${context} contained unsafe head markup; sanitized before injection`);
+  }
+  return sanitized;
+}
+function assertSafeAttributeName(name, context) {
+  if (!/^[A-Za-z_:][A-Za-z0-9_.:-]*$/.test(name) || /^on/i.test(name)) {
+    throw new OpenElementError(`Unsafe attribute in ${context}: "${name}"`, {
+      code: 'UNSAFE_HEAD_INJECTION',
+      statusCode: 400,
+      recoverable: false
+    });
+  }
+}
+/**
+ * Assert that HTML content does NOT contain <script> tags.
+ * Scripts must go through inject.scripts for URL validation.
+ */ export function assertNoScriptTags(html, context) {
+  if (/<script[\s>/]/i.test(html)) {
+    throw new OpenElementError(`${context} must not contain <script> tags. Use inject.scripts for scripts so ` + 'openElement can validate script URLs and mark the generated head injection as trusted.', {
+      code: 'UNSAFE_HEAD_INJECTION',
+      statusCode: 400,
+      recoverable: false
+    });
+  }
+}
+/**
+ * Validate a URL string for known XSS vectors (javascript:, data:, etc.).
+ * Also validates percent-encoding is not malformed.
+ * Returns the normalized URL string.
+ */ export function validateSafeUrl(url, context) {
+  // Normalise: decode URL encoding, strip whitespace, lowercase
+  const normalised = url.trim();
+  try {
+    const decoded = decodeURIComponent(normalised); // catch malformed %XX
+    const lower = decoded.toLowerCase().trim();
+    const blockedProtocols = [
+      'javascript:',
+      'data:',
+      'vbscript:',
+      'file:'
+    ];
+    for (const proto of blockedProtocols){
+      if (lower.startsWith(proto)) {
+        throw new OpenElementError(`Unsafe URL in ${context}: "${url}" - ${proto} protocol is not allowed`, {
+          code: 'UNSAFE_URL',
+          statusCode: 400,
+          recoverable: false
+        });
+      }
+    }
+  } catch (e) {
+    // H-01 fix: Re-throw OpenElementError so security warnings are not swallowed
+    if (e instanceof OpenElementError) throw e;
+    // v0.14.3: decodeURIComponent can throw for two reasons:
+    //   1. Malicious URLs with invalid percent-encoding (e.g., "%ZZ")
+    //   2. Legitimate URLs with lone surrogates (rare, but valid URI-encoded)
+    // We treat actual URIError as unsafe, but log the distinction for debugging.
+    if (e instanceof URIError) {
+      log.debug(`decodeURIComponent failed for URL in ${context}: "${url}" - ${e.message}. ` + 'This may be a legitimate encoding issue or a malicious URL.');
+    }
+    throw new OpenElementError(`Invalid URL in ${context}: "${url}" - malformed percent-encoding`, {
+      code: 'UNSAFE_URL',
+      statusCode: 400,
+      recoverable: false
+    });
+  }
+  return normalised;
+}
+/**
+ * Build the headExtras string from FrameworkOptions.inject.
+ *
+ * Serializes headFragments, stylesheets, and scripts into a single
+ * HTML string to inject into <head>. Validates all URLs and ensures
+ * no raw <script> tags bypass the structured injection APIs.
+ */ export function buildHeadExtras(options) {
+  // If direct headExtras provided, validate and return
+  if (options.headExtras) {
+    assertNoScriptTags(options.headExtras, 'headExtras');
+    return {
+      headExtras: sanitizeHeadHtml(options.headExtras, 'headExtras'),
+      allowHeadExtrasScripts: false
+    };
+  }
+  // No inject config - no head extras
+  if (!options.inject) {
+    return {
+      headExtras: undefined,
+      allowHeadExtrasScripts: false
+    };
+  }
+  const fragments = [];
+  // headFragments FIRST (meta, styles, anti-flash) - must exist in DOM
+  // before scripts that reference them (e.g. theme-init.js removes anti-flash).
+  for (const frag of options.inject.headFragments || []){
+    assertNoScriptTags(frag, 'inject.headFragments');
+    fragments.push(sanitizeHeadHtml(frag, 'inject.headFragments'));
+  }
+  // Stylesheets second
+  for (const entry of options.inject.stylesheets || []){
+    const isObj = typeof entry === 'object';
+    const href = isObj ? entry.href : entry;
+    validateSafeUrl(href, 'inject.stylesheets');
+    const safeHref = escapeHtmlAttr(href);
+    const linkAttrs = [
+      `rel="stylesheet"`,
+      `href="${safeHref}"`
+    ];
+    if (isObj) {
+      if (entry.integrity) linkAttrs.push(`integrity="${escapeHtmlAttr(entry.integrity)}"`);
+      if (entry.crossorigin) linkAttrs.push(`crossorigin="${escapeHtmlAttr(entry.crossorigin)}"`);
+      if (entry.integrity && !entry.crossorigin) linkAttrs.push('crossorigin="anonymous"');
+      if (entry.attrs) {
+        for (const [k, v] of Object.entries(entry.attrs)){
+          if (v !== undefined && v !== false) {
+            assertSafeAttributeName(k, 'inject.stylesheets.attrs');
+            linkAttrs.push(v === true ? escapeHtmlAttr(k) : `${escapeHtmlAttr(k)}="${escapeHtmlAttr(String(v))}"`);
+          }
+        }
+      }
+    }
+    fragments.push(`<link ${linkAttrs.join(' ')} />`);
+  }
+  // Scripts last - depend on headFragments being in DOM
+  for (const script of options.inject.scripts || []){
+    const isObjectScript = typeof script === 'object';
+    const src = isObjectScript ? script.src : script;
+    validateSafeUrl(src, 'inject.scripts');
+    const attrs = {
+      ...!isObjectScript || script.type ? {
+        type: isObjectScript ? script.type : 'module'
+      } : {},
+      ...isObjectScript && script.defer ? {
+        defer: true
+      } : {},
+      ...isObjectScript && script.async ? {
+        async: true
+      } : {},
+      src
+    };
+    if (isObjectScript && script.attrs) {
+      for (const [k, v] of Object.entries(script.attrs)){
+        assertSafeAttributeName(k, 'inject.scripts.attrs');
+        attrs[k] = v;
+      }
+    }
+    // H-04/05 fix: Add SRI attributes for CDN security
+    if (isObjectScript) {
+      if (script.integrity) attrs.integrity = script.integrity;
+      if (script.crossorigin) attrs.crossorigin = script.crossorigin;
+      else if (script.integrity) attrs.crossorigin = 'anonymous';
+    }
+    const attrText = Object.entries(attrs).filter(([, value])=>value !== undefined && value !== false).map(([name, value])=>value === true ? escapeHtmlAttr(name) : `${escapeHtmlAttr(name)}="${escapeHtmlAttr(String(value))}"`).join(' ');
+    fragments.push(`<script ${attrText}></script>`);
+  }
+  return {
+    headExtras: fragments.join('\n  '),
+    allowHeadExtrasScripts: true
+  };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/adapter-vite/src/head-injection.ts"],"sourcesContent":["/**\n * @openelement/adapter-vite — Head injection validation & serialization.\n *\n * Extracted from index.ts in v0.22 (SOP-004: adapter-vite decomposition).\n *\n * Provides:\n * - assertNoScriptTags() — script tag safety check for head fragments\n * - validateSafeUrl()    — URL protocol validation against XSS vectors\n * - buildHeadExtras()    — serialize headFragments, stylesheets, and scripts\n *                          into a single headExtras string\n */\n\nimport type { FrameworkOptions } from '@openelement/protocol/framework';\n\nimport { OpenElementError } from '@openelement/core/errors';\nimport { escapeAttr as escapeHtmlAttr } from '@openelement/core';\nimport { createLogger } from '@openelement/core/logger';\n// @deno-types=\"npm:@types/sanitize-html@^2\"\nimport sanitizeHtml, { type IOptions as SanitizeHtmlOptions } from 'sanitize-html';\n\nconst log = createLogger('adapter-vite:head-injection');\n\nconst SAFE_SCHEMES = ['http', 'https', 'mailto', 'tel', 'sms'];\nconst HEAD_SANITIZE_OPTIONS: SanitizeHtmlOptions = {\n  allowedTags: ['base', 'link', 'meta', 'noscript', 'style', 'title'],\n  allowedAttributes: {\n    base: ['href', 'target'],\n    link: [\n      'as',\n      'crossorigin',\n      'href',\n      'hreflang',\n      'imagesizes',\n      'imagesrcset',\n      'integrity',\n      'media',\n      'referrerpolicy',\n      'rel',\n      'sizes',\n      'title',\n      'type',\n    ],\n    meta: ['charset', 'content', 'http-equiv', 'name', 'property'],\n    noscript: [],\n    style: ['media', 'nonce', 'title'],\n    title: [],\n  },\n  allowedSchemes: SAFE_SCHEMES,\n  allowedSchemesByTag: {\n    link: SAFE_SCHEMES,\n    base: ['http', 'https'],\n  },\n  allowedSchemesAppliedToAttributes: ['href', 'src', 'action', 'formaction', 'xlink:href'],\n  allowProtocolRelative: false,\n  allowVulnerableTags: true,\n};\n\nfunction sanitizeHeadHtml(html: string, context: string): string {\n  const sanitized = sanitizeHtml(html, HEAD_SANITIZE_OPTIONS);\n  if (sanitized.trim() !== html.trim()) {\n    log.warn(`${context} contained unsafe head markup; sanitized before injection`);\n  }\n  return sanitized;\n}\n\nfunction assertSafeAttributeName(name: string, context: string): void {\n  if (!/^[A-Za-z_:][A-Za-z0-9_.:-]*$/.test(name) || /^on/i.test(name)) {\n    throw new OpenElementError(`Unsafe attribute in ${context}: \"${name}\"`, {\n      code: 'UNSAFE_HEAD_INJECTION',\n      statusCode: 400,\n      recoverable: false,\n    });\n  }\n}\n\n/**\n * Assert that HTML content does NOT contain <script> tags.\n * Scripts must go through inject.scripts for URL validation.\n */\nexport function assertNoScriptTags(html: string, context: string): void {\n  if (/<script[\\s>/]/i.test(html)) {\n    throw new OpenElementError(\n      `${context} must not contain <script> tags. Use inject.scripts for scripts so ` +\n        'openElement can validate script URLs and mark the generated head injection as trusted.',\n      {\n        code: 'UNSAFE_HEAD_INJECTION',\n        statusCode: 400,\n        recoverable: false,\n      },\n    );\n  }\n}\n\n/**\n * Validate a URL string for known XSS vectors (javascript:, data:, etc.).\n * Also validates percent-encoding is not malformed.\n * Returns the normalized URL string.\n */\nexport function validateSafeUrl(url: string, context: string): string {\n  // Normalise: decode URL encoding, strip whitespace, lowercase\n  const normalised = url.trim();\n  try {\n    const decoded = decodeURIComponent(normalised); // catch malformed %XX\n    const lower = decoded.toLowerCase().trim();\n    const blockedProtocols = ['javascript:', 'data:', 'vbscript:', 'file:'];\n    for (const proto of blockedProtocols) {\n      if (lower.startsWith(proto)) {\n        throw new OpenElementError(\n          `Unsafe URL in ${context}: \"${url}\" - ${proto} protocol is not allowed`,\n          {\n            code: 'UNSAFE_URL',\n            statusCode: 400,\n            recoverable: false,\n          },\n        );\n      }\n    }\n  } catch (e) {\n    // H-01 fix: Re-throw OpenElementError so security warnings are not swallowed\n    if (e instanceof OpenElementError) throw e;\n    // v0.14.3: decodeURIComponent can throw for two reasons:\n    //   1. Malicious URLs with invalid percent-encoding (e.g., \"%ZZ\")\n    //   2. Legitimate URLs with lone surrogates (rare, but valid URI-encoded)\n    // We treat actual URIError as unsafe, but log the distinction for debugging.\n    if (e instanceof URIError) {\n      log.debug(\n        `decodeURIComponent failed for URL in ${context}: \"${url}\" - ${e.message}. ` +\n          'This may be a legitimate encoding issue or a malicious URL.',\n      );\n    }\n    throw new OpenElementError(\n      `Invalid URL in ${context}: \"${url}\" - malformed percent-encoding`,\n      {\n        code: 'UNSAFE_URL',\n        statusCode: 400,\n        recoverable: false,\n      },\n    );\n  }\n  return normalised;\n}\n\n/** Result of building head extras from FrameworkOptions. */\nexport interface HeadExtrasResult {\n  headExtras: string | undefined;\n  allowHeadExtrasScripts: boolean;\n}\n\n/**\n * Build the headExtras string from FrameworkOptions.inject.\n *\n * Serializes headFragments, stylesheets, and scripts into a single\n * HTML string to inject into <head>. Validates all URLs and ensures\n * no raw <script> tags bypass the structured injection APIs.\n */\nexport function buildHeadExtras(options: FrameworkOptions): HeadExtrasResult {\n  // If direct headExtras provided, validate and return\n  if (options.headExtras) {\n    assertNoScriptTags(options.headExtras, 'headExtras');\n    return {\n      headExtras: sanitizeHeadHtml(options.headExtras, 'headExtras'),\n      allowHeadExtrasScripts: false,\n    };\n  }\n\n  // No inject config - no head extras\n  if (!options.inject) {\n    return { headExtras: undefined, allowHeadExtrasScripts: false };\n  }\n\n  const fragments: string[] = [];\n\n  // headFragments FIRST (meta, styles, anti-flash) - must exist in DOM\n  // before scripts that reference them (e.g. theme-init.js removes anti-flash).\n  for (const frag of options.inject.headFragments || []) {\n    assertNoScriptTags(frag, 'inject.headFragments');\n    fragments.push(sanitizeHeadHtml(frag, 'inject.headFragments'));\n  }\n\n  // Stylesheets second\n  for (const entry of options.inject.stylesheets || []) {\n    const isObj = typeof entry === 'object';\n    const href = isObj ? entry.href : entry;\n    validateSafeUrl(href, 'inject.stylesheets');\n    const safeHref = escapeHtmlAttr(href);\n    const linkAttrs: string[] = [`rel=\"stylesheet\"`, `href=\"${safeHref}\"`];\n    if (isObj) {\n      if (entry.integrity) linkAttrs.push(`integrity=\"${escapeHtmlAttr(entry.integrity)}\"`);\n      if (entry.crossorigin) linkAttrs.push(`crossorigin=\"${escapeHtmlAttr(entry.crossorigin)}\"`);\n      if (entry.integrity && !entry.crossorigin) linkAttrs.push('crossorigin=\"anonymous\"');\n      if (entry.attrs) {\n        for (const [k, v] of Object.entries(entry.attrs)) {\n          if (v !== undefined && v !== false) {\n            assertSafeAttributeName(k, 'inject.stylesheets.attrs');\n            linkAttrs.push(\n              v === true\n                ? escapeHtmlAttr(k)\n                : `${escapeHtmlAttr(k)}=\"${escapeHtmlAttr(String(v))}\"`,\n            );\n          }\n        }\n      }\n    }\n    fragments.push(`<link ${linkAttrs.join(' ')} />`);\n  }\n\n  // Scripts last - depend on headFragments being in DOM\n  for (const script of options.inject.scripts || []) {\n    const isObjectScript = typeof script === 'object';\n    const src = isObjectScript ? script.src : script;\n    validateSafeUrl(src, 'inject.scripts');\n    const attrs: Record<string, string | number | boolean> = {\n      ...(!isObjectScript || script.type ? { type: isObjectScript ? script.type! : 'module' } : {}),\n      ...(isObjectScript && script.defer ? { defer: true } : {}),\n      ...(isObjectScript && script.async ? { async: true } : {}),\n      src,\n    };\n    if (isObjectScript && script.attrs) {\n      for (const [k, v] of Object.entries(script.attrs)) {\n        assertSafeAttributeName(k, 'inject.scripts.attrs');\n        attrs[k] = v;\n      }\n    }\n    // H-04/05 fix: Add SRI attributes for CDN security\n    if (isObjectScript) {\n      if (script.integrity) attrs.integrity = script.integrity;\n      if (script.crossorigin) attrs.crossorigin = script.crossorigin;\n      else if (script.integrity) attrs.crossorigin = 'anonymous';\n    }\n    const attrText = Object.entries(attrs)\n      .filter(([, value]) => value !== undefined && value !== false)\n      .map(([name, value]) =>\n        value === true\n          ? escapeHtmlAttr(name)\n          : `${escapeHtmlAttr(name)}=\"${escapeHtmlAttr(String(value))}\"`\n      )\n      .join(' ');\n    fragments.push(`<script ${attrText}></script>`);\n  }\n\n  return {\n    headExtras: fragments.join('\\n  '),\n    allowHeadExtrasScripts: true,\n  };\n}\n"],"names":[],"mappings":"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"}

package/src/index.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @openelement/adapter-vite - Vite build orchestration adapter.
+ *
+ * Provides the `openPipeline()` Vite plugin that handles:
+ * - Route scanning and virtual Hono entry generation
+ * - Dev server integration via @hono/vite-dev-server
+ * - Island marking transform
+ * - SSG build pipeline (Phase 1/2/3)
+ * - Core subpath resolution (ADR 0016)
+ *
+ * Runtime code (renderDsd, defineIsland, escapeHtml, etc.) lives in @openelement/core.
+ * This package only contains Vite-specific build orchestration.
+ *
+ * For the unified openElement() entry, use @openelement/app/vite instead.
+ *
+ * v0.22 (SOP-004): Decomposed into focused modules:
+ *   head-injection.ts      - HTML fragment validation & serialization
+ *   plugin.ts              - Internal plugin factory (used by openPipeline)
+ *   subpath-resolver.ts    - JSR remote resolution (ADR 0016)
+ *   generated-data-resolver.ts - Generated app data namespace resolver
+ *
+ * This file is now a pure re-export hub (~60 lines).
+ */ import type { Plugin } from 'vite';
+import type { FrameworkOptions } from '@openelement/protocol/framework';
+export interface OpenPipelineConfig {
+  routes?: {
+    dir?: string;
+  };
+  i18n?: {
+    locales: string[];
+    defaultLocale?: string;
+  };
+  output?: {
+    outDir?: string;
+  };
+  island?: {
+    dir?: string;
+    upgradeStrategy?: string;
+  };
+  viewTransition?: boolean;
+  headExtras?: string;
+}
+export declare function openPipeline(config?: OpenPipelineConfig): Plugin[];
+export type { FrameworkOptions };
+export { OpenElementBuildContext } from "./build-context.js";
+export type { ArtifactInfo, BuildManifest } from "./build-manifest.js";
+export { printBuildManifest, scanClientBuild, scanSSGOutput } from "./build-manifest.js";
+export { buildIslandChunkMap, buildSpeculationRulesJson, extractCustomElementTags, generateIslandManifests, injectClientScript, injectCspMeta, injectDsdPolyfill, injectSpeculationRules, injectViewTransitionMeta, insertAfterHead, type IslandLayerMap, type IslandManifestEntry, type IslandStrategyMap, type PageIslandManifest, writeIslandManifests } from '@openelement/ssg';
+export type { SpeculationRulesOptions } from '@openelement/protocol/ssg';
+export type { ExternalManifest } from '@openelement/protocol/ssg';
+export { CORE_SUBPATHS, VIRTUAL_CORE_PREFIX } from "./subpath-resolver.js";
+export { assertNoScriptTags, buildHeadExtras, validateSafeUrl } from "./head-injection.js";
+export type { HeadExtrasResult } from "./head-injection.js";
+export { mdxPlugin, openMdx } from "./plugin-mdx.js";
+export type { OpenMdxPluginOptions } from "./plugin-mdx.js";
+export { createOpenElementNitroHandler } from "./nitro-mount.js";
+export type { NitroLikeRequestEvent, NitroLikeResponse, OpenElementNitroMountOptions } from "./nitro-mount.js";
+export { openPipeline as default };

package/src/index.js

@@ -0,0 +1,52 @@
+/**
+ * @openelement/adapter-vite - Vite build orchestration adapter.
+ *
+ * Provides the `openPipeline()` Vite plugin that handles:
+ * - Route scanning and virtual Hono entry generation
+ * - Dev server integration via @hono/vite-dev-server
+ * - Island marking transform
+ * - SSG build pipeline (Phase 1/2/3)
+ * - Core subpath resolution (ADR 0016)
+ *
+ * Runtime code (renderDsd, defineIsland, escapeHtml, etc.) lives in @openelement/core.
+ * This package only contains Vite-specific build orchestration.
+ *
+ * For the unified openElement() entry, use @openelement/app/vite instead.
+ *
+ * v0.22 (SOP-004): Decomposed into focused modules:
+ *   head-injection.ts      - HTML fragment validation & serialization
+ *   plugin.ts              - Internal plugin factory (used by openPipeline)
+ *   subpath-resolver.ts    - JSR remote resolution (ADR 0016)
+ *   generated-data-resolver.ts - Generated app data namespace resolver
+ *
+ * This file is now a pure re-export hub (~60 lines).
+ */ // Primary public API
+import { createOpenPlugin } from './plugin.js';
+export function openPipeline(config = {}) {
+  const options = {
+    routesDir: config.routes?.dir || 'app/routes',
+    islandsDir: config.island?.dir || 'app/islands',
+    componentsDir: 'app/components',
+    viewTransition: config.viewTransition ?? true,
+    headExtras: config.headExtras,
+    island: config.island,
+    build: config.output
+  };
+  return createOpenPlugin(options);
+}
+// Build context
+export { OpenElementBuildContext } from './build-context.js';
+export { printBuildManifest, scanClientBuild, scanSSGOutput } from './build-manifest.js';
+// SSG post-processing & island manifests (adapter-vite internal build helpers)
+export { buildIslandChunkMap, buildSpeculationRulesJson, extractCustomElementTags, generateIslandManifests, injectClientScript, injectCspMeta, injectDsdPolyfill, injectSpeculationRules, injectViewTransitionMeta, insertAfterHead, writeIslandManifests } from '@openelement/ssg';
+// Subpath resolver (public constants)
+export { CORE_SUBPATHS, VIRTUAL_CORE_PREFIX } from './subpath-resolver.js';
+// Head injection (public helpers)
+export { assertNoScriptTags, buildHeadExtras, validateSafeUrl } from './head-injection.js';
+// MDX integration
+export { mdxPlugin, openMdx } from './plugin-mdx.js';
+// Nitro runtime proof boundary
+export { createOpenElementNitroHandler } from './nitro-mount.js';
+// Default export
+export { openPipeline as default };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vaG9tZS9ydW5uZXIvd29yay9vcGVuZWxlbWVudC9vcGVuZWxlbWVudC9wYWNrYWdlcy9hZGFwdGVyLXZpdGUvc3JjL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQG9wZW5lbGVtZW50L2FkYXB0ZXItdml0ZSAtIFZpdGUgYnVpbGQgb3JjaGVzdHJhdGlvbiBhZGFwdGVyLlxuICpcbiAqIFByb3ZpZGVzIHRoZSBgb3BlblBpcGVsaW5lKClgIFZpdGUgcGx1Z2luIHRoYXQgaGFuZGxlczpcbiAqIC0gUm91dGUgc2Nhbm5pbmcgYW5kIHZpcnR1YWwgSG9ubyBlbnRyeSBnZW5lcmF0aW9uXG4gKiAtIERldiBzZXJ2ZXIgaW50ZWdyYXRpb24gdmlhIEBob25vL3ZpdGUtZGV2LXNlcnZlclxuICogLSBJc2xhbmQgbWFya2luZyB0cmFuc2Zvcm1cbiAqIC0gU1NHIGJ1aWxkIHBpcGVsaW5lIChQaGFzZSAxLzIvMylcbiAqIC0gQ29yZSBzdWJwYXRoIHJlc29sdXRpb24gKEFEUiAwMDE2KVxuICpcbiAqIFJ1bnRpbWUgY29kZSAocmVuZGVyRHNkLCBkZWZpbmVJc2xhbmQsIGVzY2FwZUh0bWwsIGV0Yy4pIGxpdmVzIGluIEBvcGVuZWxlbWVudC9jb3JlLlxuICogVGhpcyBwYWNrYWdlIG9ubHkgY29udGFpbnMgVml0ZS1zcGVjaWZpYyBidWlsZCBvcmNoZXN0cmF0aW9uLlxuICpcbiAqIEZvciB0aGUgdW5pZmllZCBvcGVuRWxlbWVudCgpIGVudHJ5LCB1c2UgQG9wZW5lbGVtZW50L2FwcC92aXRlIGluc3RlYWQuXG4gKlxuICogdjAuMjIgKFNPUC0wMDQpOiBEZWNvbXBvc2VkIGludG8gZm9jdXNlZCBtb2R1bGVzOlxuICogICBoZWFkLWluamVjdGlvbi50cyAgICAgIC0gSFRNTCBmcmFnbWVudCB2YWxpZGF0aW9uICYgc2VyaWFsaXphdGlvblxuICogICBwbHVnaW4udHMgICAgICAgICAgICAgIC0gSW50ZXJuYWwgcGx1Z2luIGZhY3RvcnkgKHVzZWQgYnkgb3BlblBpcGVsaW5lKVxuICogICBzdWJwYXRoLXJlc29sdmVyLnRzICAgIC0gSlNSIHJlbW90ZSByZXNvbHV0aW9uIChBRFIgMDAxNilcbiAqICAgZ2VuZXJhdGVkLWRhdGEtcmVzb2x2ZXIudHMgLSBHZW5lcmF0ZWQgYXBwIGRhdGEgbmFtZXNwYWNlIHJlc29sdmVyXG4gKlxuICogVGhpcyBmaWxlIGlzIG5vdyBhIHB1cmUgcmUtZXhwb3J0IGh1YiAofjYwIGxpbmVzKS5cbiAqL1xuXG4vLyBQcmltYXJ5IHB1YmxpYyBBUElcbmltcG9ydCB0eXBlIHsgUGx1Z2luIH0gZnJvbSAndml0ZSc7XG5pbXBvcnQgdHlwZSB7IEZyYW1ld29ya09wdGlvbnMgfSBmcm9tICdAb3BlbmVsZW1lbnQvcHJvdG9jb2wvZnJhbWV3b3JrJztcbmltcG9ydCB7IGNyZWF0ZU9wZW5QbHVnaW4gfSBmcm9tICcuL3BsdWdpbi5qcyc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgT3BlblBpcGVsaW5lQ29uZmlnIHtcbiAgcm91dGVzPzogeyBkaXI/OiBzdHJpbmcgfTtcbiAgaTE4bj86IHsgbG9jYWxlczogc3RyaW5nW107IGRlZmF1bHRMb2NhbGU/OiBzdHJpbmcgfTtcbiAgb3V0cHV0PzogeyBvdXREaXI/OiBzdHJpbmcgfTtcbiAgaXNsYW5kPzogeyBkaXI/OiBzdHJpbmc7IHVwZ3JhZGVTdHJhdGVneT86IHN0cmluZyB9O1xuICB2aWV3VHJhbnNpdGlvbj86IGJvb2xlYW47XG4gIGhlYWRFeHRyYXM/OiBzdHJpbmc7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBvcGVuUGlwZWxpbmUoY29uZmlnOiBPcGVuUGlwZWxpbmVDb25maWcgPSB7fSk6IFBsdWdpbltdIHtcbiAgY29uc3Qgb3B0aW9uczogRnJhbWV3b3JrT3B0aW9ucyA9IHtcbiAgICByb3V0ZXNEaXI6IGNvbmZpZy5yb3V0ZXM/LmRpciB8fCAnYXBwL3JvdXRlcycsXG4gICAgaXNsYW5kc0RpcjogY29uZmlnLmlzbGFuZD8uZGlyIHx8ICdhcHAvaXNsYW5kcycsXG4gICAgY29tcG9uZW50c0RpcjogJ2FwcC9jb21wb25lbnRzJyxcbiAgICB2aWV3VHJhbnNpdGlvbjogY29uZmlnLnZpZXdUcmFuc2l0aW9uID8/IHRydWUsXG4gICAgaGVhZEV4dHJhczogY29uZmlnLmhlYWRFeHRyYXMsXG4gICAgaXNsYW5kOiBjb25maWcuaXNsYW5kIGFzIEZyYW1ld29ya09wdGlvbnNbJ2lzbGFuZCddLFxuICAgIGJ1aWxkOiBjb25maWcub3V0cHV0IGFzIEZyYW1ld29ya09wdGlvbnNbJ2J1aWxkJ10sXG4gIH07XG4gIHJldHVybiBjcmVhdGVPcGVuUGx1Z2luKG9wdGlvbnMpO1xufVxuXG5leHBvcnQgdHlwZSB7IEZyYW1ld29ya09wdGlvbnMgfTtcblxuLy8gQnVpbGQgY29udGV4dFxuZXhwb3J0IHsgT3BlbkVsZW1lbnRCdWlsZENvbnRleHQgfSBmcm9tICcuL2J1aWxkLWNvbnRleHQuanMnO1xuXG4vLyBCdWlsZCBtYW5pZmVzdFxuZXhwb3J0IHR5cGUgeyBBcnRpZmFjdEluZm8sIEJ1aWxkTWFuaWZlc3QgfSBmcm9tICcuL2J1aWxkLW1hbmlmZXN0LmpzJztcbmV4cG9ydCB7IHByaW50QnVpbGRNYW5pZmVzdCwgc2NhbkNsaWVudEJ1aWxkLCBzY2FuU1NHT3V0cHV0IH0gZnJvbSAnLi9idWlsZC1tYW5pZmVzdC5qcyc7XG5cbi8vIFNTRyBwb3N0LXByb2Nlc3NpbmcgJiBpc2xhbmQgbWFuaWZlc3RzIChhZGFwdGVyLXZpdGUgaW50ZXJuYWwgYnVpbGQgaGVscGVycylcbmV4cG9ydCB7XG4gIGJ1aWxkSXNsYW5kQ2h1bmtNYXAsXG4gIGJ1aWxkU3BlY3VsYXRpb25SdWxlc0pzb24sXG4gIGV4dHJhY3RDdXN0b21FbGVtZW50VGFncyxcbiAgZ2VuZXJhdGVJc2xhbmRNYW5pZmVzdHMsXG4gIGluamVjdENsaWVudFNjcmlwdCxcbiAgaW5qZWN0Q3NwTWV0YSxcbiAgaW5qZWN0RHNkUG9seWZpbGwsXG4gIGluamVjdFNwZWN1bGF0aW9uUnVsZXMsXG4gIGluamVjdFZpZXdUcmFuc2l0aW9uTWV0YSxcbiAgaW5zZXJ0QWZ0ZXJIZWFkLFxuICB0eXBlIElzbGFuZExheWVyTWFwLFxuICB0eXBlIElzbGFuZE1hbmlmZXN0RW50cnksXG4gIHR5cGUgSXNsYW5kU3RyYXRlZ3lNYXAsXG4gIHR5cGUgUGFnZUlzbGFuZE1hbmlmZXN0LFxuICB3cml0ZUlzbGFuZE1hbmlmZXN0cyxcbn0gZnJvbSAnQG9wZW5lbGVtZW50L3NzZyc7XG5cbi8vIFByb3RvY29sIHR5cGUgcmUtZXhwb3J0c1xuZXhwb3J0IHR5cGUgeyBTcGVjdWxhdGlvblJ1bGVzT3B0aW9ucyB9IGZyb20gJ0BvcGVuZWxlbWVudC9wcm90b2NvbC9zc2cnO1xuXG4vLyBFeHRlcm5hbCByZXNvbHZlciB0eXBlcyB1c2VkIGJ5IHRoZSBhZGFwdGVyLXZpdGUgYnVpbGQgcGlwZWxpbmVcbmV4cG9ydCB0eXBlIHsgRXh0ZXJuYWxNYW5pZmVzdCB9IGZyb20gJ0BvcGVuZWxlbWVudC9wcm90b2NvbC9zc2cnO1xuXG4vLyBTdWJwYXRoIHJlc29sdmVyIChwdWJsaWMgY29uc3RhbnRzKVxuZXhwb3J0IHsgQ09SRV9TVUJQQVRIUywgVklSVFVBTF9DT1JFX1BSRUZJWCB9IGZyb20gJy4vc3VicGF0aC1yZXNvbHZlci5qcyc7XG5cbi8vIEhlYWQgaW5qZWN0aW9uIChwdWJsaWMgaGVscGVycylcbmV4cG9ydCB7IGFzc2VydE5vU2NyaXB0VGFncywgYnVpbGRIZWFkRXh0cmFzLCB2YWxpZGF0ZVNhZmVVcmwgfSBmcm9tICcuL2hlYWQtaW5qZWN0aW9uLmpzJztcbmV4cG9ydCB0eXBlIHsgSGVhZEV4dHJhc1Jlc3VsdCB9IGZyb20gJy4vaGVhZC1pbmplY3Rpb24uanMnO1xuXG4vLyBNRFggaW50ZWdyYXRpb25cbmV4cG9ydCB7IG1keFBsdWdpbiwgb3Blbk1keCB9IGZyb20gJy4vcGx1Z2luLW1keC5qcyc7XG5leHBvcnQgdHlwZSB7IE9wZW5NZHhQbHVnaW5PcHRpb25zIH0gZnJvbSAnLi9wbHVnaW4tbWR4LmpzJztcblxuLy8gTml0cm8gcnVudGltZSBwcm9vZiBib3VuZGFyeVxuZXhwb3J0IHsgY3JlYXRlT3BlbkVsZW1lbnROaXRyb0hhbmRsZXIgfSBmcm9tICcuL25pdHJvLW1vdW50LmpzJztcbmV4cG9ydCB0eXBlIHtcbiAgTml0cm9MaWtlUmVxdWVzdEV2ZW50LFxuICBOaXRyb0xpa2VSZXNwb25zZSxcbiAgT3BlbkVsZW1lbnROaXRyb01vdW50T3B0aW9ucyxcbn0gZnJvbSAnLi9uaXRyby1tb3VudC5qcyc7XG5cbi8vIERlZmF1bHQgZXhwb3J0XG5leHBvcnQgeyBvcGVuUGlwZWxpbmUgYXMgZGVmYXVsdCB9O1xuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0NBc0JDLEdBRUQscUJBQXFCO0FBR3JCLFNBQVMsZ0JBQWdCLFFBQVEsY0FBYztBQVcvQyxPQUFPLFNBQVMsYUFBYSxTQUE2QixDQUFDLENBQUM7RUFDMUQsTUFBTSxVQUE0QjtJQUNoQyxXQUFXLE9BQU8sTUFBTSxFQUFFLE9BQU87SUFDakMsWUFBWSxPQUFPLE1BQU0sRUFBRSxPQUFPO0lBQ2xDLGVBQWU7SUFDZixnQkFBZ0IsT0FBTyxjQUFjLElBQUk7SUFDekMsWUFBWSxPQUFPLFVBQVU7SUFDN0IsUUFBUSxPQUFPLE1BQU07SUFDckIsT0FBTyxPQUFPLE1BQU07RUFDdEI7RUFDQSxPQUFPLGlCQUFpQjtBQUMxQjtBQUlBLGdCQUFnQjtBQUNoQixTQUFTLHVCQUF1QixRQUFRLHFCQUFxQjtBQUk3RCxTQUFTLGtCQUFrQixFQUFFLGVBQWUsRUFBRSxhQUFhLFFBQVEsc0JBQXNCO0FBRXpGLCtFQUErRTtBQUMvRSxTQUNFLG1CQUFtQixFQUNuQix5QkFBeUIsRUFDekIsd0JBQXdCLEVBQ3hCLHVCQUF1QixFQUN2QixrQkFBa0IsRUFDbEIsYUFBYSxFQUNiLGlCQUFpQixFQUNqQixzQkFBc0IsRUFDdEIsd0JBQXdCLEVBQ3hCLGVBQWUsRUFLZixvQkFBb0IsUUFDZixtQkFBbUI7QUFRMUIsc0NBQXNDO0FBQ3RDLFNBQVMsYUFBYSxFQUFFLG1CQUFtQixRQUFRLHdCQUF3QjtBQUUzRSxrQ0FBa0M7QUFDbEMsU0FBUyxrQkFBa0IsRUFBRSxlQUFlLEVBQUUsZUFBZSxRQUFRLHNCQUFzQjtBQUczRixrQkFBa0I7QUFDbEIsU0FBUyxTQUFTLEVBQUUsT0FBTyxRQUFRLGtCQUFrQjtBQUdyRCwrQkFBK0I7QUFDL0IsU0FBUyw2QkFBNkIsUUFBUSxtQkFBbUI7QUFPakUsaUJBQWlCO0FBQ2pCLFNBQVMsZ0JBQWdCLE9BQU8sR0FBRyJ9

package/src/island-transform.js

@@ -0,0 +1,27 @@
+/**
+ * @openelement/adapter-vite — Island transform Vite plugin.
+ *
+ * Thin wrapper around @openelement/core/island-transform.
+ * The core logic is a pure function with zero Vite dependency;
+ * this file only adapts it to the Vite Plugin interface.
+ */ import { transformIslandSource } from '@openelement/core';
+/** Vite plugin that injects `__island` and `__tagName` markers into island components */ export function islandTransformPlugin(islandsDir) {
+  const normalizedDir = islandsDir.replace(/\\/g, '/');
+  return {
+    name: 'open:island-transform',
+    transform (code, id) {
+      try {
+        const result = transformIslandSource(code, {
+          islandsDir: normalizedDir,
+          filePath: id.replace(/\\/g, '/')
+        });
+        if (result.islands.length === 0) return null;
+        return result.code;
+      } catch (e) {
+        // Route errors through Vite's this.error() for proper build failure reporting
+        this.error(e.message);
+      }
+    }
+  };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/src/nitro-mount.d.ts

@@ -0,0 +1,24 @@
+import type { OpenElementRequestHandler } from '@openelement/core/runtime';
+export interface NitroLikeRequestEvent<Env extends Record<string, unknown> = Record<string, unknown>> {
+  request?: Request;
+  method?: string;
+  path?: string;
+  url?: string;
+  headers?: HeadersInit;
+  body?: BodyInit | null;
+  env?: Env;
+  platform?: unknown;
+}
+export interface NitroLikeResponse {
+  status: number;
+  headers: Headers;
+  body: BodyInit | null;
+  response: Response;
+}
+export interface OpenElementNitroMountOptions<Env extends Record<string, unknown> = Record<string, unknown>> {
+  handler: OpenElementRequestHandler<Env>;
+  baseUrl?: string;
+  env?: Env;
+  platform?: unknown;
+}
+export declare function createOpenElementNitroHandler<Env extends Record<string, unknown> = Record<string, unknown>>(options: OpenElementNitroMountOptions<Env>): (event: NitroLikeRequestEvent<Env>) => Promise<NitroLikeResponse>;

package/src/nitro-mount.js

@@ -0,0 +1,27 @@
+function toRequest(event, baseUrl) {
+  if (event.request) return event.request;
+  const url = event.url ? new URL(event.url, baseUrl) : new URL(event.path || '/', baseUrl);
+  return new Request(url, {
+    method: event.method || 'GET',
+    headers: event.headers,
+    body: event.body
+  });
+}
+export function createOpenElementNitroHandler(options) {
+  const baseUrl = options.baseUrl || 'http://localhost';
+  return async (event)=>{
+    const request = toRequest(event, baseUrl);
+    const context = {
+      env: event.env || options.env,
+      platform: event.platform || options.platform
+    };
+    const response = await options.handler(request, context);
+    return {
+      status: response.status,
+      headers: response.headers,
+      body: response.body,
+      response
+    };
+  };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/src/plugin-mdx.d.ts

@@ -0,0 +1,7 @@
+import type { Plugin } from 'vite';
+export interface OpenMdxPluginOptions {
+  jsxImportSource?: string;
+  development?: boolean;
+}
+export declare function mdxPlugin(options?: OpenMdxPluginOptions): Plugin;
+export { mdxPlugin as openMdx };

package/src/plugin-mdx.js

@@ -0,0 +1,15 @@
+import mdx from '@mdx-js/rollup';
+export function mdxPlugin(options = {}) {
+  const plugin = mdx({
+    jsxImportSource: options.jsxImportSource ?? '@openelement/core',
+    providerImportSource: undefined,
+    development: options.development ?? false
+  });
+  return {
+    ...plugin,
+    name: 'open:mdx',
+    enforce: 'pre'
+  };
+}
+export { mdxPlugin as openMdx };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vaG9tZS9ydW5uZXIvd29yay9vcGVuZWxlbWVudC9vcGVuZWxlbWVudC9wYWNrYWdlcy9hZGFwdGVyLXZpdGUvc3JjL3BsdWdpbi1tZHgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBQbHVnaW4gfSBmcm9tICd2aXRlJztcbmltcG9ydCBtZHggZnJvbSAnQG1keC1qcy9yb2xsdXAnO1xuXG5leHBvcnQgaW50ZXJmYWNlIE9wZW5NZHhQbHVnaW5PcHRpb25zIHtcbiAganN4SW1wb3J0U291cmNlPzogc3RyaW5nO1xuICBkZXZlbG9wbWVudD86IGJvb2xlYW47XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBtZHhQbHVnaW4ob3B0aW9uczogT3Blbk1keFBsdWdpbk9wdGlvbnMgPSB7fSk6IFBsdWdpbiB7XG4gIGNvbnN0IHBsdWdpbiA9IG1keCh7XG4gICAganN4SW1wb3J0U291cmNlOiBvcHRpb25zLmpzeEltcG9ydFNvdXJjZSA/PyAnQG9wZW5lbGVtZW50L2NvcmUnLFxuICAgIHByb3ZpZGVySW1wb3J0U291cmNlOiB1bmRlZmluZWQsXG4gICAgZGV2ZWxvcG1lbnQ6IG9wdGlvbnMuZGV2ZWxvcG1lbnQgPz8gZmFsc2UsXG4gIH0pIGFzIFBsdWdpbjtcblxuICByZXR1cm4ge1xuICAgIC4uLnBsdWdpbixcbiAgICBuYW1lOiAnb3BlbjptZHgnLFxuICAgIGVuZm9yY2U6ICdwcmUnLFxuICB9O1xufVxuXG5leHBvcnQgeyBtZHhQbHVnaW4gYXMgb3Blbk1keCB9O1xuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sU0FBUyxpQkFBaUI7QUFPakMsT0FBTyxTQUFTLFVBQVUsVUFBZ0MsQ0FBQyxDQUFDO0VBQzFELE1BQU0sU0FBUyxJQUFJO0lBQ2pCLGlCQUFpQixRQUFRLGVBQWUsSUFBSTtJQUM1QyxzQkFBc0I7SUFDdEIsYUFBYSxRQUFRLFdBQVcsSUFBSTtFQUN0QztFQUVBLE9BQU87SUFDTCxHQUFHLE1BQU07SUFDVCxNQUFNO0lBQ04sU0FBUztFQUNYO0FBQ0Y7QUFFQSxTQUFTLGFBQWEsT0FBTyxHQUFHIn0=

package/src/plugin.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Extracted from index.ts in v0.22 (SOP-004: adapter-vite decomposition).
+ *
+ * This is the core build plugin implementation. It is NOT part of the
+ * public API. Use `openPipeline()` from the main entry instead.
+ *
+ * Internal only: called by openPipeline() and the @openelement/app umbrella.
+ */ import type { Plugin } from 'vite';
+import type { FrameworkOptions } from '@openelement/protocol/framework';
+import { OpenElementBuildContext } from "./build-context.js";
+export declare function optionalPackageStubsPlugin(): Plugin;
+/**
+ * This is the core build plugin implementation. It is NOT part of the
+ * public API. Use `openPipeline()` from @openelement/adapter-vite instead.
+ *
+ * Internal only: called by openPipeline() and the @openelement/app umbrella.
+ * Jamstack: M=SSG+DSD, A=API Routes, J=Islands.
+ *
+ * @param options - Framework options
+ * @param externalCtx - Optional shared OpenElementBuildContext (used by openElement() umbrella)
+ * @internal
+ */ export declare function createOpenPlugin(options?: FrameworkOptions, externalCtx?: OpenElementBuildContext): Plugin[];