@openelement/adapter-vite 0.41.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zhi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,87 @@
+# @openelement/adapter-vite
+
+openElement build orchestration for Vite.
+
+> v0.39 surface: advanced Framework infrastructure. First-run apps should use
+> `@openelement/app/vite` or generated `@openelement/create` tasks instead of
+> importing this package directly.
+
+This package scans routes and islands, generates virtual entries, builds client
+island chunks, runs SSG, and writes post-processed HTML. It is build-time
+infrastructure; runtime primitives live in `@openelement/core`.
+
+## Install
+
+```bash
+npm install @openelement/adapter-vite
+```
+
+## Usage
+
+```ts
+import { createOpenPlugin } from '@openelement/adapter-vite/plugin';
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+  plugins: [
+    createOpenPlugin({
+      routesDir: 'app/routes',
+      islandsDir: 'app/islands',
+      componentsDir: 'app/components',
+      packageIslands: ['@openelement/ui'],
+    }),
+  ],
+});
+```
+
+Most applications should use `openElement()` from `@openelement/app/vite`
+instead; it combines the core adapter, content pipeline, and i18n with one
+shared build context.
+
+## Main Options
+
+| Option           | Default            | Purpose                                         |
+| ---------------- | ------------------ | ----------------------------------------------- |
+| `routesDir`      | `'app/routes'`     | Page routes, API routes, renderers, middleware. |
+| `islandsDir`     | `'app/islands'`    | Local Custom Elements for client upgrade.       |
+| `componentsDir`  | `'app/components'` | Shared server-rendered components.              |
+| `packageIslands` | `[]`               | Packages exporting an `islands` metadata array. |
+| `html`           | `{}`               | Document metadata.                              |
+| `inject`         | none               | Structured stylesheet/script/head injection.    |
+| `middleware`     | none               | Hono middleware configuration.                  |
+| `pwa`            | none               | PWA metadata and assets.                        |
+
+## SSG Pipeline
+
+```text
+Phase 1: route, API, middleware, and island scan
+Phase 2: client island entry and browser chunks
+Phase 3: SSR bundle, Hono toSSG(), HTML post-processing
+```
+
+## Build Utilities
+
+```ts
+import {
+  buildIslandChunkMap,
+  extractCustomElementTags,
+  generateIslandManifests,
+  injectClientScript,
+  injectCspMeta,
+  injectDsdPolyfill,
+  scanClientBuild,
+  scanSSGOutput,
+  writeIslandManifests,
+} from '@openelement/adapter-vite';
+```
+
+## Registry Boundary
+
+`packageIslands` currently scans packages that export `islands`. It should not be
+treated as a complete marketplace or registry protocol. Future `open add`
+behavior must first validate a CEM-compatible manifest, generate a dry-run diff,
+and only then update config and generated registration.
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "@openelement/adapter-vite",
+  "version": "0.41.0-alpha.1",
+  "type": "module",
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js",
+      "default": "./src/index.js"
+    },
+    "./build-context": {
+      "types": "./src/build-context.d.ts",
+      "import": "./src/build-context.js",
+      "default": "./src/build-context.js"
+    },
+    "./head-injection": {
+      "types": "./src/head-injection.d.ts",
+      "import": "./src/head-injection.js",
+      "default": "./src/head-injection.js"
+    },
+    "./nitro-mount": {
+      "types": "./src/nitro-mount.d.ts",
+      "import": "./src/nitro-mount.js",
+      "default": "./src/nitro-mount.js"
+    },
+    "./plugin": {
+      "types": "./src/plugin.d.ts",
+      "import": "./src/plugin.js",
+      "default": "./src/plugin.js"
+    },
+    "./generated-data-resolver": {
+      "types": "./src/generated-data-resolver.d.ts",
+      "import": "./src/generated-data-resolver.js",
+      "default": "./src/generated-data-resolver.js"
+    },
+    "./subpath-resolver": {
+      "types": "./src/subpath-resolver.d.ts",
+      "import": "./src/subpath-resolver.js",
+      "default": "./src/subpath-resolver.js"
+    },
+    "./plugin-mdx": {
+      "types": "./src/plugin-mdx.d.ts",
+      "import": "./src/plugin-mdx.js",
+      "default": "./src/plugin-mdx.js"
+    },
+    "./cli/build": {
+      "types": "./src/cli/build.d.ts",
+      "import": "./src/cli/build.js",
+      "default": "./src/cli/build.js"
+    },
+    "./cli/build-client": {
+      "types": "./src/cli/build-client.d.ts",
+      "import": "./src/cli/build-client.js",
+      "default": "./src/cli/build-client.js"
+    },
+    "./cli/build-ssg": {
+      "types": "./src/cli/build-ssg.d.ts",
+      "import": "./src/cli/build-ssg.js",
+      "default": "./src/cli/build-ssg.js"
+    }
+  },
+  "dependencies": {
+    "@mdx-js/rollup": "^3.1.1",
+    "@hono/vite-dev-server": "^0.25.3",
+    "sanitize-html": "^2.17.4",
+    "@types/sanitize-html": "^2",
+    "vite": "^8.0.10",
+    "@openelement/protocol": "^0.41.0-alpha.1",
+    "@openelement/core": "^0.41.0-alpha.1",
+    "@openelement/ssg": "^0.41.0-alpha.1",
+    "@openelement/content": "^0.41.0-alpha.1",
+    "@deno/shim-deno": "~0.19.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/open-element/openelement.git"
+  },
+  "keywords": [
+    "openelement",
+    "web-components",
+    "ssg",
+    "framework",
+    "deno"
+  ]
+}

package/src/alias-utils.js

@@ -0,0 +1,39 @@
+/**
+ * @openelement/adapter-vite - Alias normalization helpers.
+ *
+ * Utilities for converting user-provided alias mappings into Vite's Alias[]
+ * shape with absolute, root-relative replacements.
+ */ import { resolve } from 'node:path';
+function normalizeAliasReplacement(root, replacement) {
+  return replacement.startsWith('/') || /^[A-Za-z]:/.test(replacement) || replacement.startsWith('file:') || replacement.startsWith('\0') ? replacement : resolve(root, replacement);
+}
+function aliasSpecificity(find) {
+  return typeof find === 'string' ? find.length : 0;
+}
+function sortAliasEntries(aliases) {
+  return [
+    ...aliases
+  ].sort((a, b)=>{
+    return aliasSpecificity(b.find) - aliasSpecificity(a.find);
+  });
+}
+/**
+ * Normalize a user-provided alias map into Vite Alias entries.
+ *
+ * Accepts either a record of find -> replacement strings or an existing Alias
+ * array. Relative replacements are resolved against `root`. Entries are sorted
+ * by specificity so longer/more specific aliases match first.
+ */ export function normalizeViteAliases(aliases, root) {
+  if (!aliases) return undefined;
+  if (Array.isArray(aliases)) {
+    return sortAliasEntries(aliases.map((alias)=>typeof alias.replacement === 'string' ? {
+        ...alias,
+        replacement: normalizeAliasReplacement(root, alias.replacement)
+      } : alias));
+  }
+  return sortAliasEntries(Object.entries(aliases).map(([find, replacement])=>({
+      find,
+      replacement: normalizeAliasReplacement(root, replacement)
+    })));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/src/build-context.d.ts

@@ -0,0 +1,111 @@
+/**
+ * @openelement/adapter-vite - openElement Build Context
+ *
+ * Shared mutable state for all openElement Vite plugins.
+ * Replaces the closure-captured variables (honoEntryCode, scannedIslandTagNames, etc.)
+ * with a single object that's explicitly passed around.
+ *
+ * Also replaces the .openElement/ temp directory as IPC between build phases:
+ * - Phase 1 (open:build) writes metadata -> ctx fields
+ * - Phase 2 (build-client) reads metadata -> ctx fields
+ * - Phase 3 (build-ssg) reads metadata -> ctx fields
+ * - Sub-plugins (openContent, openI18n) write their data -> ctx fields
+ *
+ * ctx is passed via explicit parameter - no globalThis or module-level discovery.
+ * use openElement() from @openelement/app/vite for the recommended unified entry.
+ *
+ * Fields are grouped by Phase to improve type safety and maintainability.
+ */ import type { Alias, ResolvedConfig } from 'vite';
+import type { CompatibilityClassification, FrameworkOptions, HydrationStrategy, OpenElementBlogOptions, OpenElementHeaderNavLink, OpenElementI18nContextOptions, OpenElementNavSection, RouteEntry } from '@openelement/protocol/framework';
+import type { OpenElementPackageManifest } from '@openelement/protocol/manifest';
+import type { IslandDecl, SsrAdmissionPlan } from '@openelement/protocol/ssg';
+export type Phase1Token = {
+  readonly __phase1: unique symbol;
+};
+export type Phase2Token = {
+  readonly __phase2: unique symbol;
+};
+export type Phase3Token = {
+  readonly __phase3: unique symbol;
+};
+export declare class Phase1Meta {
+  /** The generated Hono entry module code (virtual module content) */ honoEntryCode: string;
+  /** Cached routes from buildStart() for virtual entry regeneration */ cachedRoutes: RouteEntry[];
+  /** Island tag names discovered during route scanning (local islands) */ islandTagNames: string[];
+  /** Relative file paths for local islands */ islandFiles: string[];
+  /** Local island metadata indexed by tag name. */ islandMeta: Record<string, Partial<IslandDecl>>;
+  /** Package manifests discovered from npm/JSR packages */ packageManifests: OpenElementPackageManifest[];
+  /** Package island declarations extracted from manifests */ packageIslandDecls: IslandDecl[];
+  /** SSR admission plan produced before SSR entry generation. */ ssrAdmissionPlan: SsrAdmissionPlan | null;
+  /** v0.18.0: CEM-derived compatibility classifications from the classifier. */ cemClassifications: CompatibilityClassification[];
+  /** Whether the SSR+client build has completed */ buildCompleted: boolean;
+  /** Vite resolved config (set in configResolved hook) */ resolvedConfig: ResolvedConfig | null;
+  /** User-provided resolve.alias in its original format */ userResolveAlias: Record<string, string> | Alias[] | null;
+}
+export declare class Phase2Meta {
+  /** Generated client island entry code */ clientEntryCode: string;
+}
+export declare class Phase3Meta {
+  /** Generated SSG entry code (for viteBuild SSR input) */ ssgEntryCode: string;
+  /** Project root directory */ root: string;
+  /** Output directory (default: 'dist') */ outDir: string;
+  /** Base URL path (default: '/') */ base: string;
+  /** Middleware config from createOpenPlugin() options */ middleware: FrameworkOptions['middleware'] | null;
+  /** HTML document options from createOpenPlugin() options */ html: {
+    lang?: string;
+    title?: string;
+  } | null;
+  /** Island hydration strategy (default: 'idle') */ upgradeStrategy: HydrationStrategy;
+  /** View Transitions enabled (default: true) */ viewTransition: boolean;
+  /** Speculation Rules config from createOpenPlugin() options */ speculation: FrameworkOptions['speculation'] | null;
+  /** Extra HTML to inject into <head> */ headExtras: string;
+  /** Whether headExtras scripts were produced by structured injection APIs. */ allowHeadExtrasScripts: boolean;
+  /** Application shell rendered around routes. */ appShell: FrameworkOptions['appShell'];
+  /** Named route layouts selected by route meta. */ layouts: FrameworkOptions['layouts'];
+  /** SSR noExternal patterns (serialized) */ ssrNoExternal: (string | {
+    __type: 'RegExp';
+    source: string;
+    flags: string;
+  })[];
+  /** SSR deps to keep as external (resolved by Deno import() at runtime per ADR-0043) */ ssrExternal: string[];
+  /** Routes directory */ routesDir: string;
+  /** Islands directory */ islandsDir: string;
+  /** Components directory */ componentsDir: string;
+  /** ADR-0047: Pre-resolved external dependency manifest (auto-generated from deno info). */ externalManifest?: import('@openelement/protocol/ssg').ExternalManifest;
+  /** Skip Deno pre-resolution, use regex fallback. */ skipPreResolution?: boolean;
+}
+export declare class OpenElementBuildContext {
+  /** Phase completion tokens - used for compile-time ordering enforcement */ readonly _phaseTokens: {
+    1: Phase1Token | null;
+    2: Phase2Token | null;
+    3: Phase3Token | null;
+  };
+  /** Mark Phase 1 as complete and return the token for subsequent phases */ completePhase1(): Phase1Token;
+  /** Mark Phase 2 as complete (after Phase 1 or Phase 3) */ completePhase2(token: Phase1Token | Phase3Token): Phase2Token;
+  /** Mark Phase 3 as complete (only requires Phase 1, not Phase 2) */ completePhase3(token: Phase1Token): Phase3Token;
+  /** Populate Phase 3 invariants from resolved Vite config and framework options. */ populatePhase3(options: FrameworkOptions & {
+    allowHeadExtrasScripts?: boolean;
+  }, config: ResolvedConfig, ssrNoExternal: (string | {
+    __type: 'RegExp';
+    source: string;
+    flags: string;
+  })[]): void;
+  /** Return a read-only view of Phase 3 metadata. */ getPhase3Meta(): Readonly<Phase3Meta>;
+  /** Check whether a phase has been completed. */ isPhaseComplete(phase: 1 | 2 | 3): boolean;
+  /** Run Phase 3 after Phase 1, enforcing ordering and logging. */ runPhase3(runner: (ctx: this) => Promise<void>): Promise<void>;
+  /** Run Phase 2 after Phase 3, enforcing ordering and logging. */ runPhase2(runner: (ctx: this) => Promise<void>): Promise<void>;
+  /** Phase 1: Route scanning & build metadata */ readonly phase1: Phase1Meta;
+  /** Phase 2: Client island build state */ readonly phase2: Phase2Meta;
+  /** Phase 3: SSG rendering state */ readonly phase3: Phase3Meta;
+  /** Plugin data from content/i18n sub-plugins */ readonly plugins: {
+    blogOptions: OpenElementBlogOptions | null;
+    navSections: OpenElementNavSection[];
+    headerNav: OpenElementHeaderNavLink[];
+    sitemapOptions: Record<string, unknown> | null;
+    i18nOptions: OpenElementI18nContextOptions | null;
+    [key: string]: unknown;
+  };
+  /** Resolved framework options with defaults applied (read-only after construction) */ readonly options: FrameworkOptions;
+  constructor(options: FrameworkOptions);
+  /** Reset all mutable state (for watch mode / testing) */ reset(): void;
+}

package/src/build-context.js

@@ -0,0 +1,184 @@
+/**
+ * @openelement/adapter-vite - openElement Build Context
+ *
+ * Shared mutable state for all openElement Vite plugins.
+ * Replaces the closure-captured variables (honoEntryCode, scannedIslandTagNames, etc.)
+ * with a single object that's explicitly passed around.
+ *
+ * Also replaces the .openElement/ temp directory as IPC between build phases:
+ * - Phase 1 (open:build) writes metadata -> ctx fields
+ * - Phase 2 (build-client) reads metadata -> ctx fields
+ * - Phase 3 (build-ssg) reads metadata -> ctx fields
+ * - Sub-plugins (openContent, openI18n) write their data -> ctx fields
+ *
+ * ctx is passed via explicit parameter - no globalThis or module-level discovery.
+ * use openElement() from @openelement/app/vite for the recommended unified entry.
+ *
+ * Fields are grouped by Phase to improve type safety and maintainability.
+ */ import { createLogger } from '@openelement/core/logger';
+const log = createLogger('core');
+export class Phase1Meta {
+  /** The generated Hono entry module code (virtual module content) */ honoEntryCode = '';
+  /** Cached routes from buildStart() for virtual entry regeneration */ cachedRoutes = [];
+  /** Island tag names discovered during route scanning (local islands) */ islandTagNames = [];
+  /** Relative file paths for local islands */ islandFiles = [];
+  /** Local island metadata indexed by tag name. */ islandMeta = {};
+  /** Package manifests discovered from npm/JSR packages */ packageManifests = [];
+  /** Package island declarations extracted from manifests */ packageIslandDecls = [];
+  /** SSR admission plan produced before SSR entry generation. */ ssrAdmissionPlan = null;
+  /** v0.18.0: CEM-derived compatibility classifications from the classifier. */ cemClassifications = [];
+  /** Whether the SSR+client build has completed */ buildCompleted = false;
+  /** Vite resolved config (set in configResolved hook) */ resolvedConfig = null;
+  /** User-provided resolve.alias in its original format */ userResolveAlias = null;
+}
+export class Phase2Meta {
+  /** Generated client island entry code */ clientEntryCode = '';
+}
+export class Phase3Meta {
+  /** Generated SSG entry code (for viteBuild SSR input) */ ssgEntryCode = '';
+  /** Project root directory */ root = '';
+  /** Output directory (default: 'dist') */ outDir = 'dist';
+  /** Base URL path (default: '/') */ base = '/';
+  /** Middleware config from createOpenPlugin() options */ middleware = null;
+  /** HTML document options from createOpenPlugin() options */ html = null;
+  /** Island hydration strategy (default: 'idle') */ upgradeStrategy = 'idle';
+  /** View Transitions enabled (default: true) */ viewTransition = true;
+  /** Speculation Rules config from createOpenPlugin() options */ speculation = null;
+  /** Extra HTML to inject into <head> */ headExtras = '';
+  /** Whether headExtras scripts were produced by structured injection APIs. */ allowHeadExtrasScripts = false;
+  /** Application shell rendered around routes. */ appShell = undefined;
+  /** Named route layouts selected by route meta. */ layouts = undefined;
+  /** SSR noExternal patterns (serialized) */ ssrNoExternal = [];
+  /** SSR deps to keep as external (resolved by Deno import() at runtime per ADR-0043) */ ssrExternal = [];
+  /** Routes directory */ routesDir = 'app/routes';
+  /** Islands directory */ islandsDir = 'app/islands';
+  /** Components directory */ componentsDir = 'app/components';
+  /** ADR-0047: Pre-resolved external dependency manifest (auto-generated from deno info). */ externalManifest;
+  /** Skip Deno pre-resolution, use regex fallback. */ skipPreResolution;
+}
+export class OpenElementBuildContext {
+  /** Phase completion tokens - used for compile-time ordering enforcement */ _phaseTokens = {
+    1: null,
+    2: null,
+    3: null
+  };
+  /** Mark Phase 1 as complete and return the token for subsequent phases */ completePhase1() {
+    const token = {
+      __phase1: Symbol()
+    };
+    this._phaseTokens[1] = token;
+    return token;
+  }
+  /** Mark Phase 2 as complete (after Phase 1 or Phase 3) */ completePhase2(token) {
+    if (this._phaseTokens[1] !== token && this._phaseTokens[3] !== token) {
+      throw new Error('Phase 2 called before Phase 1 completed');
+    }
+    const t2 = {
+      __phase2: Symbol()
+    };
+    this._phaseTokens[2] = t2;
+    return t2;
+  }
+  /** Mark Phase 3 as complete (only requires Phase 1, not Phase 2) */ completePhase3(token) {
+    if (this._phaseTokens[1] !== token) {
+      throw new Error('Phase 3 called before Phase 1 completed');
+    }
+    const t3 = {
+      __phase3: Symbol()
+    };
+    this._phaseTokens[3] = t3;
+    return t3;
+  }
+  /** Populate Phase 3 invariants from resolved Vite config and framework options. */ populatePhase3(options, config, ssrNoExternal) {
+    let base = config.base || '/';
+    if (!base.endsWith('/')) base += '/';
+    this.phase3.root = config.root;
+    this.phase3.outDir = options.build?.outDir || 'dist';
+    this.phase3.base = base;
+    this.phase3.ssrNoExternal = ssrNoExternal;
+    this.phase3.routesDir = options.routesDir || 'app/routes';
+    this.phase3.islandsDir = options.islandsDir || 'app/islands';
+    this.phase3.componentsDir = options.componentsDir || 'app/components';
+    this.phase3.middleware = options.middleware || null;
+    this.phase3.html = options.html || null;
+    this.phase3.upgradeStrategy = options.island?.upgradeStrategy || 'idle';
+    this.phase3.viewTransition = options.viewTransition ?? true;
+    this.phase3.speculation = options.speculation ?? null;
+    this.phase3.headExtras = options.headExtras || '';
+    this.phase3.allowHeadExtrasScripts = options.allowHeadExtrasScripts || false;
+    this.phase3.appShell = options.appShell;
+    this.phase3.layouts = options.layouts;
+  }
+  /** Return a read-only view of Phase 3 metadata. */ getPhase3Meta() {
+    return this.phase3;
+  }
+  /** Check whether a phase has been completed. */ isPhaseComplete(phase) {
+    return this._phaseTokens[phase] !== null;
+  }
+  /** Run Phase 3 after Phase 1, enforcing ordering and logging. */ async runPhase3(runner) {
+    const phase1Token = this._phaseTokens[1];
+    if (!phase1Token) {
+      throw new Error('Phase 3 called before Phase 1 completed');
+    }
+    this.completePhase3(phase1Token);
+    log.info('[3/3] Static site generation...');
+    try {
+      await runner(this);
+      log.info('[3/3] Static site generation - complete');
+    } catch (error) {
+      log.error(`[3/3] Static site generation - FAILED: ${error}`);
+      throw error;
+    }
+  }
+  /** Run Phase 2 after Phase 3, enforcing ordering and logging. */ async runPhase2(runner) {
+    const phase3Token = this._phaseTokens[3];
+    if (!phase3Token) {
+      throw new Error('Phase 2 called before Phase 3 completed');
+    }
+    this.completePhase2(phase3Token);
+    log.info('[2/3] Client island build...');
+    try {
+      await runner(this);
+      log.info('[2/3] Client island build - complete');
+    } catch (error) {
+      log.error(`[2/3] Client island build - FAILED: ${error}`);
+      throw error;
+    }
+  }
+  /** Phase 1: Route scanning & build metadata */ phase1 = new Phase1Meta();
+  /** Phase 2: Client island build state */ phase2 = new Phase2Meta();
+  /** Phase 3: SSG rendering state */ phase3 = new Phase3Meta();
+  /** Plugin data from content/i18n sub-plugins */ plugins = {
+    blogOptions: null,
+    navSections: [],
+    headerNav: [],
+    sitemapOptions: null,
+    i18nOptions: null
+  };
+  /** Resolved framework options with defaults applied (read-only after construction) */ options;
+  constructor(options){
+    this.options = options;
+  }
+  /** Reset all mutable state (for watch mode / testing) */ reset() {
+    this._phaseTokens[1] = null;
+    this._phaseTokens[2] = null;
+    this._phaseTokens[3] = null;
+    const userResolveAlias = this.phase1.userResolveAlias;
+    // NOTE: userResolveAlias is NOT reset - it's user configuration, not
+    // build state. It's set in config()/configResolved() and must persist
+    // through buildStart() for Phase 2 and 3 to use.
+    Object.assign(this.phase1, new Phase1Meta(), {
+      userResolveAlias
+    });
+    Object.assign(this.phase2, new Phase2Meta());
+    Object.assign(this.phase3, new Phase3Meta());
+    Object.assign(this.plugins, {
+      blogOptions: null,
+      navSections: [],
+      headerNav: [],
+      sitemapOptions: null,
+      i18nOptions: null
+    });
+  }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/adapter-vite/src/build-context.ts"],"sourcesContent":["/**\n * @openelement/adapter-vite - openElement Build Context\n *\n * Shared mutable state for all openElement Vite plugins.\n * Replaces the closure-captured variables (honoEntryCode, scannedIslandTagNames, etc.)\n * with a single object that's explicitly passed around.\n *\n * Also replaces the .openElement/ temp directory as IPC between build phases:\n * - Phase 1 (open:build) writes metadata -> ctx fields\n * - Phase 2 (build-client) reads metadata -> ctx fields\n * - Phase 3 (build-ssg) reads metadata -> ctx fields\n * - Sub-plugins (openContent, openI18n) write their data -> ctx fields\n *\n * ctx is passed via explicit parameter - no globalThis or module-level discovery.\n * use openElement() from @openelement/app/vite for the recommended unified entry.\n *\n * Fields are grouped by Phase to improve type safety and maintainability.\n */\n\nimport type { Alias, ResolvedConfig } from 'vite';\nimport type {\n  CompatibilityClassification,\n  FrameworkOptions,\n  HydrationStrategy,\n  OpenElementBlogOptions,\n  OpenElementHeaderNavLink,\n  OpenElementI18nContextOptions,\n  OpenElementNavSection,\n  RouteEntry,\n} from '@openelement/protocol/framework';\nimport type { OpenElementPackageManifest } from '@openelement/protocol/manifest';\nimport type { IslandDecl, SsrAdmissionPlan } from '@openelement/protocol/ssg';\nimport { createLogger } from '@openelement/core/logger';\n\nconst log = createLogger('core');\n\n// These branded types ensure Phase 2 can only run after Phase 1,\n// and Phase 3 can only run after Phase 2. The compiler catches\n// out-of-order phase calls at build time.\nexport type Phase1Token = { readonly __phase1: unique symbol };\nexport type Phase2Token = { readonly __phase2: unique symbol };\nexport type Phase3Token = { readonly __phase3: unique symbol };\n\nexport class Phase1Meta {\n  /** The generated Hono entry module code (virtual module content) */\n  honoEntryCode: string = '';\n\n  /** Cached routes from buildStart() for virtual entry regeneration */\n  cachedRoutes: RouteEntry[] = [];\n\n  /** Island tag names discovered during route scanning (local islands) */\n  islandTagNames: string[] = [];\n\n  /** Relative file paths for local islands */\n  islandFiles: string[] = [];\n\n  /** Local island metadata indexed by tag name. */\n  islandMeta: Record<string, Partial<IslandDecl>> = {};\n\n  /** Package manifests discovered from npm/JSR packages */\n  packageManifests: OpenElementPackageManifest[] = [];\n\n  /** Package island declarations extracted from manifests */\n  packageIslandDecls: IslandDecl[] = [];\n\n  /** SSR admission plan produced before SSR entry generation. */\n  ssrAdmissionPlan: SsrAdmissionPlan | null = null;\n\n  /** v0.18.0: CEM-derived compatibility classifications from the classifier. */\n  cemClassifications: CompatibilityClassification[] = [];\n\n  /** Whether the SSR+client build has completed */\n  buildCompleted: boolean = false;\n\n  /** Vite resolved config (set in configResolved hook) */\n  resolvedConfig: ResolvedConfig | null = null;\n\n  /** User-provided resolve.alias in its original format */\n  userResolveAlias: Record<string, string> | Alias[] | null = null;\n}\n\nexport class Phase2Meta {\n  /** Generated client island entry code */\n  clientEntryCode: string = '';\n}\n\nexport class Phase3Meta {\n  /** Generated SSG entry code (for viteBuild SSR input) */\n  ssgEntryCode: string = '';\n\n  /** Project root directory */\n  root: string = '';\n\n  /** Output directory (default: 'dist') */\n  outDir: string = 'dist';\n\n  /** Base URL path (default: '/') */\n  base: string = '/';\n\n  /** Middleware config from createOpenPlugin() options */\n  middleware: FrameworkOptions['middleware'] | null = null;\n\n  /** HTML document options from createOpenPlugin() options */\n  html: { lang?: string; title?: string } | null = null;\n\n  /** Island hydration strategy (default: 'idle') */\n  upgradeStrategy: HydrationStrategy = 'idle';\n\n  /** View Transitions enabled (default: true) */\n  viewTransition: boolean = true;\n\n  /** Speculation Rules config from createOpenPlugin() options */\n  speculation: FrameworkOptions['speculation'] | null = null;\n\n  /** Extra HTML to inject into <head> */\n  headExtras: string = '';\n\n  /** Whether headExtras scripts were produced by structured injection APIs. */\n  allowHeadExtrasScripts: boolean = false;\n\n  /** Application shell rendered around routes. */\n  appShell: FrameworkOptions['appShell'] = undefined;\n\n  /** Named route layouts selected by route meta. */\n  layouts: FrameworkOptions['layouts'] = undefined;\n\n  /** SSR noExternal patterns (serialized) */\n  ssrNoExternal: (string | { __type: 'RegExp'; source: string; flags: string })[] = [];\n\n  /** SSR deps to keep as external (resolved by Deno import() at runtime per ADR-0043) */\n  ssrExternal: string[] = [];\n\n  /** Routes directory */\n  routesDir: string = 'app/routes';\n\n  /** Islands directory */\n  islandsDir: string = 'app/islands';\n\n  /** Components directory */\n  componentsDir: string = 'app/components';\n\n  /** ADR-0047: Pre-resolved external dependency manifest (auto-generated from deno info). */\n  externalManifest?: import('@openelement/protocol/ssg').ExternalManifest;\n\n  /** Skip Deno pre-resolution, use regex fallback. */\n  skipPreResolution?: boolean;\n}\n\nexport class OpenElementBuildContext {\n  /** Phase completion tokens - used for compile-time ordering enforcement */\n  readonly _phaseTokens: {\n    1: Phase1Token | null;\n    2: Phase2Token | null;\n    3: Phase3Token | null;\n  } = { 1: null, 2: null, 3: null };\n\n  /** Mark Phase 1 as complete and return the token for subsequent phases */\n  completePhase1(): Phase1Token {\n    const token: Phase1Token = { __phase1: Symbol() as never };\n    this._phaseTokens[1] = token;\n    return token;\n  }\n\n  /** Mark Phase 2 as complete (after Phase 1 or Phase 3) */\n  completePhase2(token: Phase1Token | Phase3Token): Phase2Token {\n    if (this._phaseTokens[1] !== token && this._phaseTokens[3] !== token) {\n      throw new Error('Phase 2 called before Phase 1 completed');\n    }\n    const t2: Phase2Token = { __phase2: Symbol() as never };\n    this._phaseTokens[2] = t2;\n    return t2;\n  }\n\n  /** Mark Phase 3 as complete (only requires Phase 1, not Phase 2) */\n  completePhase3(token: Phase1Token): Phase3Token {\n    if (this._phaseTokens[1] !== token) {\n      throw new Error('Phase 3 called before Phase 1 completed');\n    }\n    const t3: Phase3Token = { __phase3: Symbol() as never };\n    this._phaseTokens[3] = t3;\n    return t3;\n  }\n\n  /** Populate Phase 3 invariants from resolved Vite config and framework options. */\n  populatePhase3(\n    options: FrameworkOptions & { allowHeadExtrasScripts?: boolean },\n    config: ResolvedConfig,\n    ssrNoExternal: (string | { __type: 'RegExp'; source: string; flags: string })[],\n  ): void {\n    let base = config.base || '/';\n    if (!base.endsWith('/')) base += '/';\n\n    this.phase3.root = config.root;\n    this.phase3.outDir = options.build?.outDir || 'dist';\n    this.phase3.base = base;\n    this.phase3.ssrNoExternal = ssrNoExternal;\n    this.phase3.routesDir = options.routesDir || 'app/routes';\n    this.phase3.islandsDir = options.islandsDir || 'app/islands';\n    this.phase3.componentsDir = options.componentsDir || 'app/components';\n    this.phase3.middleware = options.middleware || null;\n    this.phase3.html = options.html || null;\n    this.phase3.upgradeStrategy = options.island?.upgradeStrategy || 'idle';\n    this.phase3.viewTransition = options.viewTransition ?? true;\n    this.phase3.speculation = options.speculation ?? null;\n    this.phase3.headExtras = options.headExtras || '';\n    this.phase3.allowHeadExtrasScripts = options.allowHeadExtrasScripts || false;\n    this.phase3.appShell = options.appShell;\n    this.phase3.layouts = options.layouts;\n  }\n\n  /** Return a read-only view of Phase 3 metadata. */\n  getPhase3Meta(): Readonly<Phase3Meta> {\n    return this.phase3;\n  }\n\n  /** Check whether a phase has been completed. */\n  isPhaseComplete(phase: 1 | 2 | 3): boolean {\n    return this._phaseTokens[phase] !== null;\n  }\n\n  /** Run Phase 3 after Phase 1, enforcing ordering and logging. */\n  async runPhase3(runner: (ctx: this) => Promise<void>): Promise<void> {\n    const phase1Token = this._phaseTokens[1];\n    if (!phase1Token) {\n      throw new Error('Phase 3 called before Phase 1 completed');\n    }\n    this.completePhase3(phase1Token);\n\n    log.info('[3/3] Static site generation...');\n    try {\n      await runner(this);\n      log.info('[3/3] Static site generation - complete');\n    } catch (error) {\n      log.error(`[3/3] Static site generation - FAILED: ${error}`);\n      throw error;\n    }\n  }\n\n  /** Run Phase 2 after Phase 3, enforcing ordering and logging. */\n  async runPhase2(runner: (ctx: this) => Promise<void>): Promise<void> {\n    const phase3Token = this._phaseTokens[3];\n    if (!phase3Token) {\n      throw new Error('Phase 2 called before Phase 3 completed');\n    }\n    this.completePhase2(phase3Token);\n\n    log.info('[2/3] Client island build...');\n    try {\n      await runner(this);\n      log.info('[2/3] Client island build - complete');\n    } catch (error) {\n      log.error(`[2/3] Client island build - FAILED: ${error}`);\n      throw error;\n    }\n  }\n\n  /** Phase 1: Route scanning & build metadata */\n  readonly phase1: Phase1Meta = new Phase1Meta();\n\n  /** Phase 2: Client island build state */\n  readonly phase2: Phase2Meta = new Phase2Meta();\n\n  /** Phase 3: SSG rendering state */\n  readonly phase3: Phase3Meta = new Phase3Meta();\n\n  /** Plugin data from content/i18n sub-plugins */\n  readonly plugins: {\n    blogOptions: OpenElementBlogOptions | null;\n    navSections: OpenElementNavSection[];\n    headerNav: OpenElementHeaderNavLink[];\n    sitemapOptions: Record<string, unknown> | null;\n    i18nOptions: OpenElementI18nContextOptions | null;\n    [key: string]: unknown;\n  } = {\n    blogOptions: null,\n    navSections: [],\n    headerNav: [],\n    sitemapOptions: null,\n    i18nOptions: null,\n  };\n\n  /** Resolved framework options with defaults applied (read-only after construction) */\n  readonly options: FrameworkOptions;\n\n  constructor(options: FrameworkOptions) {\n    this.options = options;\n  }\n\n  /** Reset all mutable state (for watch mode / testing) */\n  reset(): void {\n    this._phaseTokens[1] = null;\n    this._phaseTokens[2] = null;\n    this._phaseTokens[3] = null;\n\n    const userResolveAlias = this.phase1.userResolveAlias;\n    // NOTE: userResolveAlias is NOT reset - it's user configuration, not\n    // build state. It's set in config()/configResolved() and must persist\n    // through buildStart() for Phase 2 and 3 to use.\n    Object.assign(this.phase1, new Phase1Meta(), { userResolveAlias });\n    Object.assign(this.phase2, new Phase2Meta());\n    Object.assign(this.phase3, new Phase3Meta());\n    Object.assign(this.plugins, {\n      blogOptions: null,\n      navSections: [],\n      headerNav: [],\n      sitemapOptions: null,\n      i18nOptions: null,\n    });\n  }\n}\n"],"names":[],"mappings":"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"}

package/src/build-manifest.d.ts

@@ -0,0 +1,38 @@
+/** File size info for a single artifact */ export interface ArtifactInfo {
+  name: string;
+  path: string;
+  sizeBytes: number;
+  sizeKB: string;
+}
+/** Full build manifest summary */ export interface BuildManifest {
+  phase: 1 | 2 | 3;
+  timestamp: string;
+  islands: ArtifactInfo[];
+  clientEntry: ArtifactInfo | null;
+  htmlPages: ArtifactInfo[];
+  totalJsBytes: number;
+  totalHtmlBytes: number;
+  headExtrasSize: number;
+  /** Budget warnings (files > threshold) */ warnings: string[];
+}
+/**
+ * Scan client build output (dist/client/) for island chunks.
+ */ export declare function scanClientBuild(root: string, outDir?: string): {
+  islands: ArtifactInfo[];
+  clientEntry: ArtifactInfo | null;
+  totalJsBytes: number;
+};
+/**
+ * Scan SSG output (dist/*.html) for page information.
+ */ export declare function scanSSGOutput(root: string, outDir?: string): ArtifactInfo[];
+/**
+ * Print a formatted build manifest table to console.
+ *
+ * This is called at the end of each build phase to provide observability
+ * into what was produced and how large everything is.
+ */ export declare function printBuildManifest(options: {
+  root: string;
+  outDir?: string;
+  phase: 2 | 3;
+  headExtras?: string;
+}): BuildManifest;