@openelement/app 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,64 @@
+# @openelement/app
+
+JSX-first application authoring API for openElement.
+
+> v0.39 surface: Framework product. Use this package for first-run pages,
+> layouts, islands, route metadata, and the Vite facade.
+
+Use the package root in route, island, and component modules:
+
+```tsx
+import { definePage } from '@openelement/app';
+
+export default definePage({
+  route: { path: '/' },
+  head: { title: 'Home' },
+  render() {
+    return <main>Hello openElement</main>;
+  },
+});
+```
+
+Use the `/vite` subpath in `vite.config.ts`:
+
+```ts
+import { openElement } from '@openelement/app/vite';
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+  plugins: [
+    openElement({
+      routesDir: 'app/routes',
+      islandsDir: 'app/islands',
+      packageIslands: ['@openelement/ui'],
+      content: { blog: { contentDir: 'content/blog' } },
+      i18n: { locales: ['en', 'zh'], defaultLocale: 'en' },
+    }),
+  ],
+});
+```
+
+## Authoring API
+
+```tsx
+import { defineElement, defineIsland, defineLayout, definePage } from '@openelement/app';
+```
+
+- `definePage({ route, head, renderIntent, load, render, error })` creates a file-route page from a canonical object descriptor.
+- `defineIslandConfig({ ssr, dsd, hydrate })` defines static island metadata for adapter scanning.
+- `defineIsland(tagName, render, { hydrate, dsd, ssr })` creates a browser-upgraded island.
+- `defineElement(tagName, render)` creates a DSD component.
+- `defineLayout(tagName, render)` is the layout-specific form of `defineElement()`.
+
+`DsdElement` remains the runtime primitive in `@openelement/core`, but application
+authors should start from this package.
+
+## Install
+
+```bash
+npm install @openelement/app
+```
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@openelement/app",
+  "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"
+    },
+    "./i18n": {
+      "types": "./src/i18n.d.ts",
+      "import": "./src/i18n.js",
+      "default": "./src/i18n.js"
+    },
+    "./i18n-plugin": {
+      "types": "./src/i18n-plugin.d.ts",
+      "import": "./src/i18n-plugin.js",
+      "default": "./src/i18n-plugin.js"
+    },
+    "./preact": {
+      "types": "./src/preact.d.ts",
+      "import": "./src/preact.js",
+      "default": "./src/preact.js"
+    },
+    "./vite": {
+      "types": "./src/vite.d.ts",
+      "import": "./src/vite.js",
+      "default": "./src/vite.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/open-element/openelement.git"
+  },
+  "keywords": [
+    "openelement",
+    "web-components",
+    "ssg",
+    "framework",
+    "deno"
+  ],
+  "dependencies": {
+    "preact": "^10.28.0",
+    "preact-render-to-string": "^6.5.0",
+    "vite": "^8.0.10",
+    "@openelement/protocol": "^0.41.0-alpha.1",
+    "@openelement/core": "^0.41.0-alpha.1",
+    "@openelement/element": "^0.41.0-alpha.1",
+    "@openelement/router": "^0.41.0-alpha.1",
+    "@openelement/content": "^0.41.0-alpha.1",
+    "@openelement/adapter-vite": "^0.41.0-alpha.1"
+  }
+}

package/src/authoring.d.ts

@@ -0,0 +1,93 @@
+/**
+ * @openelement/app - JSX-first application authoring API.
+ *
+ * This file is intentionally free of Vite/build imports. Route modules can
+ * import from @openelement/app without pulling adapter-vite into the runtime
+ * graph.
+ */ import { type ElementDefinition, OpenElement, type VNode } from '@openelement/element';
+import type { HydrationStrategy } from '@openelement/protocol/framework';
+export type PageRenderingMode = 'auto' | 'static' | 'dynamic';
+export type PageStreamingMode = 'auto' | 'force' | false;
+export type PageRevalidate = false | number | `${number}s` | `${number}m` | `${number}h`;
+export type PageMeta = Record<string, unknown>;
+export interface PageRouteIntent {
+  path?: string;
+  id?: string;
+  params?: readonly string[];
+}
+export interface PageRenderIntent {
+  mode?: PageRenderingMode;
+  streaming?: PageStreamingMode;
+  revalidate?: PageRevalidate;
+}
+export interface NormalizedPageRenderIntent {
+  mode: PageRenderingMode;
+  streaming: PageStreamingMode;
+  revalidate: PageRevalidate;
+}
+export interface PageRouteContext {
+  path?: string;
+  filePath?: string;
+}
+export declare class OpenElementRedirect extends Error {
+  readonly location: string;
+  readonly status: number;
+  constructor(location: string | URL, status?: number);
+}
+export declare class OpenElementNotFound extends Error {
+  readonly status: 404;
+  constructor(message?: string);
+}
+export declare function redirect(location: string | URL, status?: number): never;
+export declare function notFound(message?: string): never;
+export declare function isOpenElementRedirect(error: unknown): error is OpenElementRedirect;
+export declare function isOpenElementNotFound(error: unknown): error is OpenElementNotFound;
+export interface PageHead {
+  title?: string;
+  description?: string;
+  meta?: Array<Record<string, string | number | boolean>>;
+  dangerouslyHeadFragments?: string[];
+}
+export interface PageRenderContext<Data = unknown, Params extends Record<string, string> = Record<string, string>> {
+  data: Data;
+  params: Params;
+  request?: Request;
+  route: PageRouteContext;
+  meta: PageMeta;
+  props: Record<string, unknown>;
+}
+export interface PageErrorContext<Data = unknown, Params extends Record<string, string> = Record<string, string>> extends PageRenderContext<Data, Params> {
+  error: unknown;
+}
+export type PageRenderFunction<Data = unknown, Params extends Record<string, string> = Record<string, string>> = (context: PageRenderContext<Data, Params>) => VNode | null;
+export type PageErrorFunction<Data = unknown, Params extends Record<string, string> = Record<string, string>> = (context: PageErrorContext<Data, Params>) => VNode | null;
+export interface PageDefinition<Data = unknown, Params extends Record<string, string> = Record<string, string>> {
+  route?: PageRouteIntent;
+  head?: PageHead;
+  renderIntent?: PageRenderIntent;
+  render: PageRenderFunction<Data, Params>;
+  error?: PageErrorFunction<Data, Params>;
+}
+export interface OpenElementPageDescriptor<Data = unknown, Params extends Record<string, string> = Record<string, string>> extends Omit<PageDefinition<Data, Params>, 'render' | 'renderIntent'> {
+  kind: 'page';
+  renderIntent: NormalizedPageRenderIntent;
+  render: PageRenderFunction<Data, Params>;
+}
+type PageConstructor<Data = unknown, Params extends Record<string, string> = Record<string, string>> = typeof OpenElement & {
+  openElementPage: OpenElementPageDescriptor<Data, Params>;
+};
+/**
+ * Define a file-route page.
+ *
+ * The returned class is a DsdElement-compatible custom element constructor, so
+ * the existing renderer pipeline remains unchanged while app authors write JSX
+ * functions instead of class components.
+ */ export declare function definePage<Data = unknown, Params extends Record<string, string> = Record<string, string>>(input: PageDefinition<Data, Params>): PageConstructor<Data, Params>;
+export interface IslandConfig {
+  ssr?: boolean;
+  dsd?: boolean;
+  hydrate?: HydrationStrategy;
+}
+export type AppIslandOptions = IslandConfig;
+export declare function defineIslandConfig(config: IslandConfig): IslandConfig;
+export declare function defineIsland<Props extends Record<string, unknown> = Record<string, unknown>>(tagName: string, input: ((props: Props) => VNode | null) | ElementDefinition<Props> | CustomElementConstructor, options?: AppIslandOptions): CustomElementConstructor;

package/src/authoring.js

@@ -0,0 +1,161 @@
+import { ERROR_PREFIX } from '@openelement/core';
+/**
+ * @openelement/app - JSX-first application authoring API.
+ *
+ * This file is intentionally free of Vite/build imports. Route modules can
+ * import from @openelement/app without pulling adapter-vite into the runtime
+ * graph.
+ */ import { defineElement, OpenElement } from '@openelement/element';
+import { defineIsland as defineRuntimeIsland } from '@openelement/core';
+import { __internal_setActionData, __internal_setLoaderData } from '@openelement/router';
+export class OpenElementRedirect extends Error {
+  location;
+  status;
+  constructor(location, status = 302){
+    super(`Redirect to ${String(location)}`);
+    this.name = 'OpenElementRedirect';
+    this.location = String(location);
+    this.status = status;
+  }
+}
+export class OpenElementNotFound extends Error {
+  status = 404;
+  constructor(message = 'Not Found'){
+    super(message);
+    this.name = 'OpenElementNotFound';
+  }
+}
+export function redirect(location, status = 302) {
+  throw new OpenElementRedirect(location, status);
+}
+export function notFound(message = 'Not Found') {
+  throw new OpenElementNotFound(message);
+}
+export function isOpenElementRedirect(error) {
+  return error instanceof OpenElementRedirect || typeof error === 'object' && error !== null && error.name === 'OpenElementRedirect' && typeof error.location === 'string' && typeof error.status === 'number';
+}
+export function isOpenElementNotFound(error) {
+  return error instanceof OpenElementNotFound || typeof error === 'object' && error !== null && error.name === 'OpenElementNotFound' && error.status === 404;
+}
+class ApplicationElement extends OpenElement {
+}
+class ApplicationPageElement extends ApplicationElement {
+  __openElementParams;
+  data;
+  __openElementActionData;
+  __openElementRequest;
+  __openElementRoute;
+  __openElementMeta;
+  __openElementError;
+}
+function collectPublicProps(host) {
+  const props = {};
+  for (const key of Object.keys(host)){
+    if (key.startsWith('__openElement')) continue;
+    props[key] = host[key];
+  }
+  return props;
+}
+const PAGE_DESCRIPTOR_FIELDS = new Set([
+  'route',
+  'head',
+  'renderIntent',
+  'render',
+  'error'
+]);
+const ISLAND_CONFIG_FIELDS = new Set([
+  'ssr',
+  'dsd',
+  'hydrate'
+]);
+const HYDRATION_STRATEGIES = new Set([
+  'load',
+  'idle',
+  'visible',
+  'only'
+]);
+function assertCanonicalPageDefinition(input) {
+  if (typeof input === 'function') {
+    throw new Error(`${ERROR_PREFIX} definePage() requires a canonical object descriptor. ` + 'Use definePage({ route, head, renderIntent, render, error }).');
+  }
+  if (typeof input !== 'object' || input === null) {
+    throw new Error(`${ERROR_PREFIX} definePage() requires an object descriptor.`);
+  }
+  for (const key of Object.keys(input)){
+    if (PAGE_DESCRIPTOR_FIELDS.has(key)) continue;
+    throw new Error(`${ERROR_PREFIX} definePage() does not accept top-level "${key}". ` + 'Use only route, head, renderIntent, render, and error.');
+  }
+  if (typeof input.render !== 'function') {
+    throw new Error(`${ERROR_PREFIX} definePage() descriptor requires a render() function.`);
+  }
+}
+/**
+ * Define a file-route page.
+ *
+ * The returned class is a DsdElement-compatible custom element constructor, so
+ * the existing renderer pipeline remains unchanged while app authors write JSX
+ * functions instead of class components.
+ */ export function definePage(input) {
+  assertCanonicalPageDefinition(input);
+  const definition = input;
+  const pageDescriptor = {
+    kind: 'page',
+    ...definition,
+    renderIntent: {
+      mode: definition.renderIntent?.mode ?? 'auto',
+      streaming: definition.renderIntent?.streaming ?? 'auto',
+      revalidate: definition.renderIntent?.revalidate ?? false
+    }
+  };
+  class OpenElementPage extends ApplicationPageElement {
+    static openElementPage = pageDescriptor;
+    render() {
+      // Provide loader/action data to hooks (useLoaderData / useActionData)
+      __internal_setLoaderData(this.data);
+      __internal_setActionData(this.__openElementActionData);
+      const params = this.__openElementParams ?? this.params ?? {};
+      const data = this.data;
+      const context = {
+        data,
+        params,
+        request: this.__openElementRequest,
+        route: this.__openElementRoute ?? {},
+        meta: this.__openElementMeta ?? {},
+        props: collectPublicProps(this)
+      };
+      if (this.__openElementError !== undefined && definition.error) {
+        return definition.error({
+          ...context,
+          error: this.__openElementError
+        });
+      }
+      return definition.render(context);
+    }
+  }
+  return OpenElementPage;
+}
+export function defineIslandConfig(config) {
+  if (typeof config !== 'object' || config === null || Array.isArray(config)) {
+    throw new Error(`${ERROR_PREFIX} defineIslandConfig() requires an object descriptor.`);
+  }
+  for (const key of Object.keys(config)){
+    if (!ISLAND_CONFIG_FIELDS.has(key)) {
+      throw new Error(`${ERROR_PREFIX} defineIslandConfig() does not accept "${key}". ` + 'Use only ssr, dsd, and hydrate.');
+    }
+  }
+  if (config.hydrate !== undefined && !HYDRATION_STRATEGIES.has(config.hydrate)) {
+    throw new Error(`${ERROR_PREFIX} Invalid island hydrate strategy "${String(config.hydrate)}". ` + 'Use one of: load, idle, visible, only.');
+  }
+  return {
+    ...config
+  };
+}
+export function defineIsland(tagName, input, options = {}) {
+  const componentClass = typeof input === 'function' && input.prototype?.render ? input : defineElement(tagName, input);
+  return defineRuntimeIsland(tagName, componentClass, {
+    strategy: options.hydrate,
+    dsd: options.dsd,
+    ssr: options.ssr
+  });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/app/src/authoring.ts"],"sourcesContent":["import { ERROR_PREFIX } from '@openelement/core';\n/**\n * @openelement/app - JSX-first application authoring API.\n *\n * This file is intentionally free of Vite/build imports. Route modules can\n * import from @openelement/app without pulling adapter-vite into the runtime\n * graph.\n */\n\nimport {\n  defineElement,\n  type ElementDefinition,\n  OpenElement,\n  type VNode,\n} from '@openelement/element';\nimport { defineIsland as defineRuntimeIsland } from '@openelement/core';\nimport { __internal_setActionData, __internal_setLoaderData } from '@openelement/router';\nimport type { HydrationStrategy } from '@openelement/protocol/framework';\n\nexport type PageRenderingMode = 'auto' | 'static' | 'dynamic';\nexport type PageStreamingMode = 'auto' | 'force' | false;\nexport type PageRevalidate = false | number | `${number}s` | `${number}m` | `${number}h`;\nexport type PageMeta = Record<string, unknown>;\n\nexport interface PageRouteIntent {\n  path?: string;\n  id?: string;\n  params?: readonly string[];\n}\n\nexport interface PageRenderIntent {\n  mode?: PageRenderingMode;\n  streaming?: PageStreamingMode;\n  revalidate?: PageRevalidate;\n}\n\nexport interface NormalizedPageRenderIntent {\n  mode: PageRenderingMode;\n  streaming: PageStreamingMode;\n  revalidate: PageRevalidate;\n}\n\nexport interface PageRouteContext {\n  path?: string;\n  filePath?: string;\n}\n\nexport class OpenElementRedirect extends Error {\n  readonly location: string;\n  readonly status: number;\n\n  constructor(location: string | URL, status = 302) {\n    super(`Redirect to ${String(location)}`);\n    this.name = 'OpenElementRedirect';\n    this.location = String(location);\n    this.status = status;\n  }\n}\n\nexport class OpenElementNotFound extends Error {\n  readonly status = 404;\n\n  constructor(message = 'Not Found') {\n    super(message);\n    this.name = 'OpenElementNotFound';\n  }\n}\n\nexport function redirect(location: string | URL, status = 302): never {\n  throw new OpenElementRedirect(location, status);\n}\n\nexport function notFound(message = 'Not Found'): never {\n  throw new OpenElementNotFound(message);\n}\n\nexport function isOpenElementRedirect(error: unknown): error is OpenElementRedirect {\n  return error instanceof OpenElementRedirect ||\n    (\n      typeof error === 'object' &&\n      error !== null &&\n      (error as { name?: unknown }).name === 'OpenElementRedirect' &&\n      typeof (error as { location?: unknown }).location === 'string' &&\n      typeof (error as { status?: unknown }).status === 'number'\n    );\n}\n\nexport function isOpenElementNotFound(error: unknown): error is OpenElementNotFound {\n  return error instanceof OpenElementNotFound ||\n    (\n      typeof error === 'object' &&\n      error !== null &&\n      (error as { name?: unknown }).name === 'OpenElementNotFound' &&\n      (error as { status?: unknown }).status === 404\n    );\n}\n\nexport interface PageHead {\n  title?: string;\n  description?: string;\n  meta?: Array<Record<string, string | number | boolean>>;\n  dangerouslyHeadFragments?: string[];\n}\n\nexport interface PageRenderContext<\n  Data = unknown,\n  Params extends Record<string, string> = Record<string, string>,\n> {\n  data: Data;\n  params: Params;\n  request?: Request;\n  route: PageRouteContext;\n  meta: PageMeta;\n  props: Record<string, unknown>;\n}\n\nexport interface PageErrorContext<\n  Data = unknown,\n  Params extends Record<string, string> = Record<string, string>,\n> extends PageRenderContext<Data, Params> {\n  error: unknown;\n}\n\nexport type PageRenderFunction<\n  Data = unknown,\n  Params extends Record<string, string> = Record<string, string>,\n> = (context: PageRenderContext<Data, Params>) => VNode | null;\n\nexport type PageErrorFunction<\n  Data = unknown,\n  Params extends Record<string, string> = Record<string, string>,\n> = (context: PageErrorContext<Data, Params>) => VNode | null;\n\nexport interface PageDefinition<\n  Data = unknown,\n  Params extends Record<string, string> = Record<string, string>,\n> {\n  route?: PageRouteIntent;\n  head?: PageHead;\n  renderIntent?: PageRenderIntent;\n  render: PageRenderFunction<Data, Params>;\n  error?: PageErrorFunction<Data, Params>;\n}\n\nexport interface OpenElementPageDescriptor<\n  Data = unknown,\n  Params extends Record<string, string> = Record<string, string>,\n> extends Omit<PageDefinition<Data, Params>, 'render' | 'renderIntent'> {\n  kind: 'page';\n  renderIntent: NormalizedPageRenderIntent;\n  render: PageRenderFunction<Data, Params>;\n}\n\ntype PageHostProps = {\n  __openElementParams?: Record<string, string>;\n  data?: unknown;\n  __openElementActionData?: unknown;\n  __openElementRequest?: Request;\n  __openElementRoute?: PageRouteContext;\n  __openElementMeta?: PageMeta;\n  __openElementError?: unknown;\n};\n\nabstract class ApplicationElement extends OpenElement {\n  [key: string]: unknown;\n}\n\nabstract class ApplicationPageElement extends ApplicationElement implements PageHostProps {\n  __openElementParams?: Record<string, string>;\n  data?: unknown;\n  __openElementActionData?: unknown;\n  __openElementRequest?: Request;\n  __openElementRoute?: PageRouteContext;\n  __openElementMeta?: PageMeta;\n  __openElementError?: unknown;\n}\n\ntype PageConstructor<\n  Data = unknown,\n  Params extends Record<string, string> = Record<string, string>,\n> = typeof OpenElement & {\n  openElementPage: OpenElementPageDescriptor<Data, Params>;\n};\n\nfunction collectPublicProps(host: Record<string, unknown>): Record<string, unknown> {\n  const props: Record<string, unknown> = {};\n  for (const key of Object.keys(host)) {\n    if (key.startsWith('__openElement')) continue;\n    props[key] = host[key];\n  }\n  return props;\n}\n\nconst PAGE_DESCRIPTOR_FIELDS = new Set([\n  'route',\n  'head',\n  'renderIntent',\n  'render',\n  'error',\n]);\n\nconst ISLAND_CONFIG_FIELDS = new Set(['ssr', 'dsd', 'hydrate']);\nconst HYDRATION_STRATEGIES = new Set(['load', 'idle', 'visible', 'only']);\n\nfunction assertCanonicalPageDefinition(input: unknown): asserts input is PageDefinition {\n  if (typeof input === 'function') {\n    throw new Error(\n      `${ERROR_PREFIX} definePage() requires a canonical object descriptor. ` +\n        'Use definePage({ route, head, renderIntent, render, error }).',\n    );\n  }\n  if (typeof input !== 'object' || input === null) {\n    throw new Error(`${ERROR_PREFIX} definePage() requires an object descriptor.`);\n  }\n  for (const key of Object.keys(input)) {\n    if (PAGE_DESCRIPTOR_FIELDS.has(key)) continue;\n    throw new Error(\n      `${ERROR_PREFIX} definePage() does not accept top-level \"${key}\". ` +\n        'Use only route, head, renderIntent, render, and error.',\n    );\n  }\n  if (typeof (input as { render?: unknown }).render !== 'function') {\n    throw new Error(`${ERROR_PREFIX} definePage() descriptor requires a render() function.`);\n  }\n}\n\n/**\n * Define a file-route page.\n *\n * The returned class is a DsdElement-compatible custom element constructor, so\n * the existing renderer pipeline remains unchanged while app authors write JSX\n * functions instead of class components.\n */\nexport function definePage<\n  Data = unknown,\n  Params extends Record<string, string> = Record<string, string>,\n>(\n  input: PageDefinition<Data, Params>,\n): PageConstructor<Data, Params> {\n  assertCanonicalPageDefinition(input);\n  const definition = input;\n  const pageDescriptor = {\n    kind: 'page',\n    ...definition,\n    renderIntent: {\n      mode: definition.renderIntent?.mode ?? 'auto',\n      streaming: definition.renderIntent?.streaming ?? 'auto',\n      revalidate: definition.renderIntent?.revalidate ?? false,\n    },\n  } as OpenElementPageDescriptor<Data, Params>;\n\n  class OpenElementPage extends ApplicationPageElement {\n    static openElementPage = pageDescriptor;\n\n    override render(): VNode | null {\n      // Provide loader/action data to hooks (useLoaderData / useActionData)\n      __internal_setLoaderData(this.data);\n      __internal_setActionData(this.__openElementActionData);\n\n      const params = (this.__openElementParams ?? this.params ?? {}) as Params;\n      const data = this.data as Data;\n      const context = {\n        data,\n        params,\n        request: this.__openElementRequest,\n        route: this.__openElementRoute ?? {},\n        meta: this.__openElementMeta ?? {},\n        props: collectPublicProps(this),\n      };\n\n      if (this.__openElementError !== undefined && definition.error) {\n        return definition.error({ ...context, error: this.__openElementError });\n      }\n\n      return definition.render(context);\n    }\n  }\n\n  return OpenElementPage;\n}\n\nexport interface IslandConfig {\n  ssr?: boolean;\n  dsd?: boolean;\n  hydrate?: HydrationStrategy;\n}\n\nexport type AppIslandOptions = IslandConfig;\n\nexport type IslandConfigType = IslandConfig;\n\nexport function defineIslandConfig(config: IslandConfig): IslandConfig {\n  if (typeof config !== 'object' || config === null || Array.isArray(config)) {\n    throw new Error(`${ERROR_PREFIX} defineIslandConfig() requires an object descriptor.`);\n  }\n  for (const key of Object.keys(config)) {\n    if (!ISLAND_CONFIG_FIELDS.has(key)) {\n      throw new Error(\n        `${ERROR_PREFIX} defineIslandConfig() does not accept \"${key}\". ` +\n          'Use only ssr, dsd, and hydrate.',\n      );\n    }\n  }\n  if (config.hydrate !== undefined && !HYDRATION_STRATEGIES.has(config.hydrate)) {\n    throw new Error(\n      `${ERROR_PREFIX} Invalid island hydrate strategy \"${String(config.hydrate)}\". ` +\n        'Use one of: load, idle, visible, only.',\n    );\n  }\n  return { ...config };\n}\n\nexport function defineIsland<Props extends Record<string, unknown> = Record<string, unknown>>(\n  tagName: string,\n  input: ((props: Props) => VNode | null) | ElementDefinition<Props> | CustomElementConstructor,\n  options: AppIslandOptions = {},\n): CustomElementConstructor {\n  const componentClass = typeof input === 'function' && input.prototype?.render\n    ? input as CustomElementConstructor\n    : defineElement(tagName, input as ((props: Props) => VNode | null) | ElementDefinition<Props>);\n  return defineRuntimeIsland(tagName, componentClass, {\n    strategy: options.hydrate,\n    dsd: options.dsd,\n    ssr: options.ssr,\n  });\n}\n"],"names":[],"mappings":"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"}

package/src/i18n-plugin.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @openelement/app/i18n-plugin - Node-only Vite plugin for i18n
+ *
+ * deno-api-free:ignore — build-time Vite plugin, allowed to use node:*.
+ *
+ * This module uses node:process, node:path, node:fs and MUST NOT be imported
+ * from the main @openelement/app entry to avoid pulling Node built-ins into
+ * client island bundles.
+ *
+ * Standalone usage requires explicit ctx parameter:
+ * ```ts
+ * openI18n({ locales: ['en', 'zh'], defaultLocale: 'en', ctx });  // ctx must be explicitly passed
+ * ```
+ */ import type { Plugin } from 'vite';
+import type { OpenElementBuildContextLike } from '@openelement/protocol/framework';
+import type { OpenElementI18nOptions } from "./i18n-runtime.js";
+/**
+ * Generate TypeScript module source code for i18n configuration.
+ * The output is a self-contained .ts file that exports locales,
+ * defaultLocale, and helper functions.
+ *
+ * SOP-001: Virtual Modules Removal — replaces @openelement/generated/i18n.
+ *
+ * @param locales - Array of locale code strings (e.g. ['en', 'zh'])
+ * @param defaultLocale - Default locale code (e.g. 'en')
+ * @returns TypeScript module source string
+ */ export declare function writeI18nDataModule(locales: string[], defaultLocale: string): string;
+/**
+ * openElement i18n Vite plugin.
+ * Configures locale options for route-level i18n helpers.
+ */ export declare function openI18n(options: OpenElementI18nOptions & {
+  ctx?: OpenElementBuildContextLike;
+}): Plugin;
+export default openI18n;

package/src/i18n-plugin.js

@@ -0,0 +1,81 @@
+/**
+ * @openelement/app/i18n-plugin - Node-only Vite plugin for i18n
+ *
+ * deno-api-free:ignore — build-time Vite plugin, allowed to use node:*.
+ *
+ * This module uses node:process, node:path, node:fs and MUST NOT be imported
+ * from the main @openelement/app entry to avoid pulling Node built-ins into
+ * client island bundles.
+ *
+ * Standalone usage requires explicit ctx parameter:
+ * ```ts
+ * openI18n({ locales: ['en', 'zh'], defaultLocale: 'en', ctx });  // ctx must be explicitly passed
+ * ```
+ */ import { createLogger } from '@openelement/core/logger';
+import { formatError } from '@openelement/core/errors';
+// ponytail: build-time Vite plugin, deno-api-free:ignore applies
+import process from 'node:process';
+import { join } from 'node:path';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { loadI18nData } from './i18n-runtime.js';
+const log = createLogger('i18n');
+// ─── Data utilities (node-only) ───────────────────────────────────
+/**
+ * Generate TypeScript module source code for i18n configuration.
+ * The output is a self-contained .ts file that exports locales,
+ * defaultLocale, and helper functions.
+ *
+ * SOP-001: Virtual Modules Removal — replaces @openelement/generated/i18n.
+ *
+ * @param locales - Array of locale code strings (e.g. ['en', 'zh'])
+ * @param defaultLocale - Default locale code (e.g. 'en')
+ * @returns TypeScript module source string
+ */ export function writeI18nDataModule(locales, defaultLocale) {
+  return [
+    '// Auto-generated by @openelement/app/i18n — do not edit',
+    `export const locales = ${JSON.stringify(locales)};`,
+    `export const defaultLocale = "${defaultLocale}";`,
+    '',
+    'export function getDefaultLocale(): string { return defaultLocale; }',
+    'export function getI18nOptions() { return { locales, defaultLocale }; }'
+  ].join('\n') + '\n';
+}
+// ─── Vite plugin ─────────────────────────────────────────────────
+/**
+ * openElement i18n Vite plugin.
+ * Configures locale options for route-level i18n helpers.
+ */ export function openI18n(options) {
+  // ctx must be explicitly provided (via openElement() umbrella or direct param)
+  const ctx = options.ctx;
+  return {
+    name: 'open:i18n',
+    buildStart () {
+      // ADR 0018: Use loadI18nData() pure function - zero module state
+      const i18nData = loadI18nData(options);
+      // Write i18n options to ctx (shared build context)
+      // The @openelement/generated/i18n plugin reads ctx.plugins.i18nOptions in its load() hook
+      if (ctx) {
+        ctx.plugins.i18nOptions = {
+          locales: i18nData.locales,
+          defaultLocale: i18nData.defaultLocale
+        };
+      }
+      // SOP-001: Write generated i18n data module to disk
+      try {
+        const dataDir = join(process.cwd(), 'app', 'data');
+        mkdirSync(dataDir, {
+          recursive: true
+        });
+        const i18nModule = writeI18nDataModule(i18nData.locales, i18nData.defaultLocale);
+        writeFileSync(join(dataDir, '_generated-i18n-data.ts'), i18nModule, 'utf-8');
+        log.info(`I18n: wrote _generated-i18n-data.ts (${i18nData.locales.join(', ')})`);
+      } catch (err) {
+        log.warn(`Failed to write _generated-i18n-data.ts: ${formatError(err)}`);
+      }
+      log.info(`${options.locales.join(', ')} (default: ${options.defaultLocale})`);
+    }
+  };
+}
+// Use @openelement/app/i18n for runtime helpers: i18nStaticPaths, loadI18nData, switchLocale, normalizeLocalePath
+export default openI18n;
+//# sourceMappingURL=data:application/json;base64,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

package/src/i18n-runtime.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @openelement/app/i18n-runtime - Runtime-safe i18n helpers (no node:* modules)
+ *
+ * Separated from i18n-plugin.ts to prevent node:process/node:path/node:fs from
+ * being pulled into client island bundles via @openelement/app main re-exports.
+ *
+ * Route-level helpers:
+ * ```ts
+ * import { i18nStaticPaths, switchLocale } from '@openelement/app/i18n';
+ * ```
+ */ export interface OpenElementI18nOptions {
+  /** Available locale codes, e.g. ['en', 'zh'] */ locales: string[];
+  /** Default locale, e.g. 'en' */ defaultLocale: string;
+}
+/**
+ * Pure function: load i18n configuration.
+ * No module-level state. No side effects.
+ *
+ * This replaces the stateful initI18nData() + getI18nOptions() pattern.
+ * For virtual module consumers, use @openelement/generated/i18n instead.
+ */ export declare function loadI18nData(options: OpenElementI18nOptions): OpenElementI18nOptions;
+/**
+ * Generate getStaticPaths() return for locale-aware routes.
+ *
+ * ADR 0018: locales parameter is now REQUIRED (no module-level state fallback).
+ * Import locales from @openelement/generated/i18n in route components.
+ *
+ * Usage in route file:
+ * ```ts
+ * import { i18nStaticPaths } from '@openelement/app/i18n';
+ * import { locales } from '@openelement/generated/i18n';
+ *
+ * export function getStaticPaths() {
+ *   return i18nStaticPaths(locales); // -> [{ locale: 'en' }, { locale: 'zh' }]
+ * }
+ * ```
+ */ export declare function i18nStaticPaths(locales: string[]): Array<Record<string, string>>;
+/**
+ * Switch a URL path to a different locale.
+ * e.g. switchLocale('/en/guide/overview', 'zh') -> '/zh/guide/overview'
+ *      switchLocale('/guide/overview', 'zh', ['en', 'zh']) -> '/zh/guide/overview'
+ */ export declare function switchLocale(currentPath: string, targetLocale: string, locales: string[]): string;

package/src/i18n-runtime.js

@@ -0,0 +1,65 @@
+/**
+ * @openelement/app/i18n-runtime - Runtime-safe i18n helpers (no node:* modules)
+ *
+ * Separated from i18n-plugin.ts to prevent node:process/node:path/node:fs from
+ * being pulled into client island bundles via @openelement/app main re-exports.
+ *
+ * Route-level helpers:
+ * ```ts
+ * import { i18nStaticPaths, switchLocale } from '@openelement/app/i18n';
+ * ```
+ */ // ─── Types ────────────────────────────────────────────────────────
+// ─── Data utilities ───────────────────────────────────────────────
+/**
+ * Pure function: load i18n configuration.
+ * No module-level state. No side effects.
+ *
+ * This replaces the stateful initI18nData() + getI18nOptions() pattern.
+ * For virtual module consumers, use @openelement/generated/i18n instead.
+ */ export function loadI18nData(options) {
+  return {
+    ...options,
+    locales: [
+      ...options.locales
+    ]
+  };
+}
+// ─── Route helpers ────────────────────────────────────────────────
+/**
+ * Generate getStaticPaths() return for locale-aware routes.
+ *
+ * ADR 0018: locales parameter is now REQUIRED (no module-level state fallback).
+ * Import locales from @openelement/generated/i18n in route components.
+ *
+ * Usage in route file:
+ * ```ts
+ * import { i18nStaticPaths } from '@openelement/app/i18n';
+ * import { locales } from '@openelement/generated/i18n';
+ *
+ * export function getStaticPaths() {
+ *   return i18nStaticPaths(locales); // -> [{ locale: 'en' }, { locale: 'zh' }]
+ * }
+ * ```
+ */ export function i18nStaticPaths(locales) {
+  return locales.map((locale)=>({
+      locale
+    }));
+}
+/**
+ * Switch a URL path to a different locale.
+ * e.g. switchLocale('/en/guide/overview', 'zh') -> '/zh/guide/overview'
+ *      switchLocale('/guide/overview', 'zh', ['en', 'zh']) -> '/zh/guide/overview'
+ */ export function switchLocale(currentPath, targetLocale, locales) {
+  // Strip any existing locale prefix
+  let stripped = currentPath;
+  for (const loc of locales){
+    if (stripped === `/${loc}` || stripped.startsWith(`/${loc}/`)) {
+      stripped = stripped.slice(loc.length + 1) || '/';
+      break;
+    }
+  }
+  // Prepend target locale
+  return `/${targetLocale}${stripped}`;
+}
+export { normalizeLocalePath } from '@openelement/router/i18n';
+//# sourceMappingURL=data:application/json;base64,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

package/src/i18n.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @openelement/app/i18n - Runtime-safe i18n helpers (no node:* modules)
+ *
+ * Thin re-export barrel from i18n-runtime.ts.
+ * The node-only Vite plugin is in i18n-plugin.ts and must NOT be re-exported here,
+ * to prevent node:process/node:path/node:fs from being pulled into client
+ * island bundles via @openelement/app main re-exports.
+ *
+ * Route-level helpers:
+ * ```ts
+ * import { i18nStaticPaths, switchLocale } from '@openelement/app/i18n';
+ * ```
+ */ export type { OpenElementI18nOptions } from "./i18n-runtime.js";
+export { i18nStaticPaths, loadI18nData, switchLocale } from "./i18n-runtime.js";
+export type { LocalePath } from '@openelement/router/i18n';
+export { normalizeLocalePath } from '@openelement/router/i18n';

package/src/i18n.js

@@ -0,0 +1,15 @@
+/**
+ * @openelement/app/i18n - Runtime-safe i18n helpers (no node:* modules)
+ *
+ * Thin re-export barrel from i18n-runtime.ts.
+ * The node-only Vite plugin is in i18n-plugin.ts and must NOT be re-exported here,
+ * to prevent node:process/node:path/node:fs from being pulled into client
+ * island bundles via @openelement/app main re-exports.
+ *
+ * Route-level helpers:
+ * ```ts
+ * import { i18nStaticPaths, switchLocale } from '@openelement/app/i18n';
+ * ```
+ */ export { i18nStaticPaths, loadI18nData, switchLocale } from './i18n-runtime.js';
+export { normalizeLocalePath } from '@openelement/router/i18n';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vaG9tZS9ydW5uZXIvd29yay9vcGVuZWxlbWVudC9vcGVuZWxlbWVudC9wYWNrYWdlcy9hcHAvc3JjL2kxOG4udHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAb3BlbmVsZW1lbnQvYXBwL2kxOG4gLSBSdW50aW1lLXNhZmUgaTE4biBoZWxwZXJzIChubyBub2RlOiogbW9kdWxlcylcbiAqXG4gKiBUaGluIHJlLWV4cG9ydCBiYXJyZWwgZnJvbSBpMThuLXJ1bnRpbWUudHMuXG4gKiBUaGUgbm9kZS1vbmx5IFZpdGUgcGx1Z2luIGlzIGluIGkxOG4tcGx1Z2luLnRzIGFuZCBtdXN0IE5PVCBiZSByZS1leHBvcnRlZCBoZXJlLFxuICogdG8gcHJldmVudCBub2RlOnByb2Nlc3Mvbm9kZTpwYXRoL25vZGU6ZnMgZnJvbSBiZWluZyBwdWxsZWQgaW50byBjbGllbnRcbiAqIGlzbGFuZCBidW5kbGVzIHZpYSBAb3BlbmVsZW1lbnQvYXBwIG1haW4gcmUtZXhwb3J0cy5cbiAqXG4gKiBSb3V0ZS1sZXZlbCBoZWxwZXJzOlxuICogYGBgdHNcbiAqIGltcG9ydCB7IGkxOG5TdGF0aWNQYXRocywgc3dpdGNoTG9jYWxlIH0gZnJvbSAnQG9wZW5lbGVtZW50L2FwcC9pMThuJztcbiAqIGBgYFxuICovXG5cbmV4cG9ydCB0eXBlIHsgT3BlbkVsZW1lbnRJMThuT3B0aW9ucyB9IGZyb20gJy4vaTE4bi1ydW50aW1lLmpzJztcbmV4cG9ydCB7IGkxOG5TdGF0aWNQYXRocywgbG9hZEkxOG5EYXRhLCBzd2l0Y2hMb2NhbGUgfSBmcm9tICcuL2kxOG4tcnVudGltZS5qcyc7XG5leHBvcnQgdHlwZSB7IExvY2FsZVBhdGggfSBmcm9tICdAb3BlbmVsZW1lbnQvcm91dGVyL2kxOG4nO1xuZXhwb3J0IHsgbm9ybWFsaXplTG9jYWxlUGF0aCB9IGZyb20gJ0BvcGVuZWxlbWVudC9yb3V0ZXIvaTE4bic7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7OztDQVlDLEdBR0QsU0FBUyxlQUFlLEVBQUUsWUFBWSxFQUFFLFlBQVksUUFBUSxvQkFBb0I7QUFFaEYsU0FBUyxtQkFBbUIsUUFBUSwyQkFBMkIifQ==

package/src/index.d.ts

@@ -0,0 +1,5 @@
+export { defineIsland, defineIslandConfig, definePage, isOpenElementNotFound, isOpenElementRedirect, notFound, OpenElementNotFound, OpenElementRedirect, redirect } from "./authoring.js";
+export type { AppIslandOptions, IslandConfig, NormalizedPageRenderIntent, OpenElementPageDescriptor, PageDefinition, PageErrorContext, PageErrorFunction, PageHead, PageMeta, PageRenderContext, PageRenderFunction, PageRenderingMode, PageRenderIntent, PageRevalidate, PageRouteContext, PageRouteIntent, PageStreamingMode } from "./authoring.js";
+export type { Action, ActionContext, Loader, LoaderContext } from '@openelement/protocol/data';
+export { defineElement, defineLayout } from '@openelement/element';
+export type { ElementDefinition } from '@openelement/element';

package/src/index.js

@@ -0,0 +1,4 @@
+export { defineIsland, defineIslandConfig, definePage, isOpenElementNotFound, isOpenElementRedirect, notFound, OpenElementNotFound, OpenElementRedirect, redirect } from './authoring.js';
+// Re-export from @openelement/element for convenience
+export { defineElement, defineLayout } from '@openelement/element';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vaG9tZS9ydW5uZXIvd29yay9vcGVuZWxlbWVudC9vcGVuZWxlbWVudC9wYWNrYWdlcy9hcHAvc3JjL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7XG4gIGRlZmluZUlzbGFuZCxcbiAgZGVmaW5lSXNsYW5kQ29uZmlnLFxuICBkZWZpbmVQYWdlLFxuICBpc09wZW5FbGVtZW50Tm90Rm91bmQsXG4gIGlzT3BlbkVsZW1lbnRSZWRpcmVjdCxcbiAgbm90Rm91bmQsXG4gIE9wZW5FbGVtZW50Tm90Rm91bmQsXG4gIE9wZW5FbGVtZW50UmVkaXJlY3QsXG4gIHJlZGlyZWN0LFxufSBmcm9tICcuL2F1dGhvcmluZy5qcyc7XG5leHBvcnQgdHlwZSB7XG4gIEFwcElzbGFuZE9wdGlvbnMsXG4gIElzbGFuZENvbmZpZyxcbiAgTm9ybWFsaXplZFBhZ2VSZW5kZXJJbnRlbnQsXG4gIE9wZW5FbGVtZW50UGFnZURlc2NyaXB0b3IsXG4gIFBhZ2VEZWZpbml0aW9uLFxuICBQYWdlRXJyb3JDb250ZXh0LFxuICBQYWdlRXJyb3JGdW5jdGlvbixcbiAgUGFnZUhlYWQsXG4gIFBhZ2VNZXRhLFxuICBQYWdlUmVuZGVyQ29udGV4dCxcbiAgUGFnZVJlbmRlckZ1bmN0aW9uLFxuICBQYWdlUmVuZGVyaW5nTW9kZSxcbiAgUGFnZVJlbmRlckludGVudCxcbiAgUGFnZVJldmFsaWRhdGUsXG4gIFBhZ2VSb3V0ZUNvbnRleHQsXG4gIFBhZ2VSb3V0ZUludGVudCxcbiAgUGFnZVN0cmVhbWluZ01vZGUsXG59IGZyb20gJy4vYXV0aG9yaW5nLmpzJztcblxuLy8gUmUtZXhwb3J0IHJvdXRlIGRhdGEgdHlwZXMgZnJvbSBwcm90b2NvbCBmb3IgY29udmVuaWVuY2VcbmV4cG9ydCB0eXBlIHsgQWN0aW9uLCBBY3Rpb25Db250ZXh0LCBMb2FkZXIsIExvYWRlckNvbnRleHQgfSBmcm9tICdAb3BlbmVsZW1lbnQvcHJvdG9jb2wvZGF0YSc7XG5cbi8vIFJlLWV4cG9ydCBmcm9tIEBvcGVuZWxlbWVudC9lbGVtZW50IGZvciBjb252ZW5pZW5jZVxuZXhwb3J0IHsgZGVmaW5lRWxlbWVudCwgZGVmaW5lTGF5b3V0IH0gZnJvbSAnQG9wZW5lbGVtZW50L2VsZW1lbnQnO1xuZXhwb3J0IHR5cGUgeyBFbGVtZW50RGVmaW5pdGlvbiB9IGZyb20gJ0BvcGVuZWxlbWVudC9lbGVtZW50JztcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxTQUNFLFlBQVksRUFDWixrQkFBa0IsRUFDbEIsVUFBVSxFQUNWLHFCQUFxQixFQUNyQixxQkFBcUIsRUFDckIsUUFBUSxFQUNSLG1CQUFtQixFQUNuQixtQkFBbUIsRUFDbkIsUUFBUSxRQUNILGlCQUFpQjtBQXdCeEIsc0RBQXNEO0FBQ3RELFNBQVMsYUFBYSxFQUFFLFlBQVksUUFBUSx1QkFBdUIifQ==

package/src/preact.d.ts

@@ -0,0 +1,8 @@
+import { type ComponentChild } from 'preact';
+import type { IslandConfig } from "./authoring.js";
+export type PreactIslandProps = Record<string, unknown>;
+export type PreactIslandComponent<Props extends PreactIslandProps = PreactIslandProps> = (props: Props) => ComponentChild;
+export interface PreactIslandOptions extends IslandConfig {
+  props?: PreactIslandProps;
+}
+export declare function definePreactIsland<Props extends PreactIslandProps = PreactIslandProps>(tagName: string, Component: PreactIslandComponent<Props>, options?: PreactIslandOptions): CustomElementConstructor;

package/src/preact.js

@@ -0,0 +1,69 @@
+/**
+ * @openelement/app/preact — Preact island support.
+ *
+ * Creates custom elements that extend OpenElement and render Preact
+ * components through the DSD SSR pipeline. On the server, the Preact
+ * component is rendered to a string using preact-render-to-string and
+ * wrapped as trusted HTML in OpenElement's render(). On the client,
+ * preactHydrate or preactRender takes over in the clientActivate() hook.
+ *
+ * @module @openelement/app/preact
+ */ import { OpenElement, trustedHtml } from '@openelement/element';
+import { getSsrProps } from '@openelement/core';
+import { h, hydrate as preactHydrate, render as preactRender } from 'preact';
+import { renderToString } from 'preact-render-to-string';
+function assertCustomElementTag(tagName) {
+  if (!/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/.test(tagName)) {
+    throw new Error(`openElement: "${tagName}" is not a valid custom element name. ` + 'Use lowercase ASCII letters, digits, and at least one hyphen.');
+  }
+}
+function collectAttributes(host) {
+  const props = {};
+  const attrs = host.attributes;
+  if (!attrs) return props;
+  for (const attr of Array.from(attrs)){
+    if (attr.name === 'data-ssr-props') continue;
+    props[attr.name] = attr.value;
+  }
+  return props;
+}
+function resolveProps(host, baseProps) {
+  return {
+    ...baseProps,
+    ...collectAttributes(host),
+    ...getSsrProps(host) ?? {}
+  };
+}
+export function definePreactIsland(tagName, Component, options = {}) {
+  assertCustomElementTag(tagName);
+  const baseProps = options.props ?? {};
+  class OpenElementPreactIsland extends OpenElement {
+    render() {
+      if (typeof document === 'undefined') {
+        // SSR path: render Preact component to string, return as trusted HTML
+        const html = renderToString(h(Component, resolveProps(this, baseProps)));
+        return trustedHtml(html);
+      }
+      // Client: let clientActivate() handle Preact hydration/render
+      return null;
+    }
+    clientActivate() {
+      const root = this.shadowRoot ?? this.attachShadow({
+        mode: 'open'
+      });
+      const vnode = h(Component, resolveProps(this, baseProps));
+      if (options.ssr !== false) {
+        // DSD hydration: the shadow DOM already has SSR-rendered content
+        preactHydrate(vnode, root);
+      } else {
+        // CSR: full render from scratch
+        preactRender(vnode, root);
+      }
+    }
+  }
+  if (typeof customElements !== 'undefined' && !customElements.get(tagName)) {
+    customElements.define(tagName, OpenElementPreactIsland);
+  }
+  return OpenElementPreactIsland;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/src/vite.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @openelement/app/vite - Unified openElement Vite plugin entry.
+ *
+ * Kept separate from the route authoring API so application routes can import
+ * @openelement/app without loading Vite/build orchestration.
+ */ import type { Plugin } from 'vite';
+import type { FrameworkOptions } from '@openelement/protocol/framework';
+import type { OpenElementContentOptions } from '@openelement/content';
+import type { OpenElementI18nOptions } from "./i18n-runtime.js";
+/** Options for the openElement() unified Vite entry. */ export interface OpenElementOptions extends FrameworkOptions {
+  /** Content module options (blog + nav + sitemap). Omit to disable. */ content?: OpenElementContentOptions;
+  /** i18n module options. Omit to disable. */ i18n?: OpenElementI18nOptions;
+}
+export declare function openElement(options?: OpenElementOptions): Plugin[];
+export default openElement;

package/src/vite.js

@@ -0,0 +1,40 @@
+/**
+ * @openelement/app/vite - Unified openElement Vite plugin entry.
+ *
+ * Kept separate from the route authoring API so application routes can import
+ * @openelement/app without loading Vite/build orchestration.
+ */ import { OpenElementBuildContext } from '@openelement/adapter-vite';
+import { createOpenPlugin } from '@openelement/adapter-vite/plugin';
+import { openContent } from '@openelement/content';
+import { openI18n } from './i18n-plugin.js';
+import { createLogger } from '@openelement/core/logger';
+const log = createLogger('app');
+export function openElement(options = {}) {
+  const { content: contentOpts, i18n: i18nOpts, ...coreOpts } = options;
+  const ctx = new OpenElementBuildContext({
+    ...coreOpts,
+    routesDir: coreOpts.routesDir || 'app/routes',
+    islandsDir: coreOpts.islandsDir || 'app/islands',
+    componentsDir: coreOpts.componentsDir || 'app/components'
+  });
+  const plugins = [
+    ...createOpenPlugin(coreOpts, ctx)
+  ];
+  if (i18nOpts) {
+    plugins.push(openI18n({
+      ...i18nOpts,
+      ctx
+    }));
+    log.info('i18n plugin loaded');
+  }
+  if (contentOpts) {
+    plugins.push(...openContent({
+      ...contentOpts,
+      ctx
+    }));
+    log.info('Content plugin loaded');
+  }
+  return plugins;
+}
+export default openElement;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vaG9tZS9ydW5uZXIvd29yay9vcGVuZWxlbWVudC9vcGVuZWxlbWVudC9wYWNrYWdlcy9hcHAvc3JjL3ZpdGUudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAb3BlbmVsZW1lbnQvYXBwL3ZpdGUgLSBVbmlmaWVkIG9wZW5FbGVtZW50IFZpdGUgcGx1Z2luIGVudHJ5LlxuICpcbiAqIEtlcHQgc2VwYXJhdGUgZnJvbSB0aGUgcm91dGUgYXV0aG9yaW5nIEFQSSBzbyBhcHBsaWNhdGlvbiByb3V0ZXMgY2FuIGltcG9ydFxuICogQG9wZW5lbGVtZW50L2FwcCB3aXRob3V0IGxvYWRpbmcgVml0ZS9idWlsZCBvcmNoZXN0cmF0aW9uLlxuICovXG5cbmltcG9ydCB0eXBlIHsgUGx1Z2luIH0gZnJvbSAndml0ZSc7XG5pbXBvcnQgdHlwZSB7IEZyYW1ld29ya09wdGlvbnMgfSBmcm9tICdAb3BlbmVsZW1lbnQvcHJvdG9jb2wvZnJhbWV3b3JrJztcbmltcG9ydCB0eXBlIHsgT3BlbkVsZW1lbnRDb250ZW50T3B0aW9ucyB9IGZyb20gJ0BvcGVuZWxlbWVudC9jb250ZW50JztcbmltcG9ydCB0eXBlIHsgT3BlbkVsZW1lbnRJMThuT3B0aW9ucyB9IGZyb20gJy4vaTE4bi1ydW50aW1lLmpzJztcblxuaW1wb3J0IHsgT3BlbkVsZW1lbnRCdWlsZENvbnRleHQgfSBmcm9tICdAb3BlbmVsZW1lbnQvYWRhcHRlci12aXRlJztcbmltcG9ydCB7IGNyZWF0ZU9wZW5QbHVnaW4gfSBmcm9tICdAb3BlbmVsZW1lbnQvYWRhcHRlci12aXRlL3BsdWdpbic7XG5pbXBvcnQgeyBvcGVuQ29udGVudCB9IGZyb20gJ0BvcGVuZWxlbWVudC9jb250ZW50JztcbmltcG9ydCB7IG9wZW5JMThuIH0gZnJvbSAnLi9pMThuLXBsdWdpbi5qcyc7XG5pbXBvcnQgeyBjcmVhdGVMb2dnZXIgfSBmcm9tICdAb3BlbmVsZW1lbnQvY29yZS9sb2dnZXInO1xuXG5jb25zdCBsb2cgPSBjcmVhdGVMb2dnZXIoJ2FwcCcpO1xuXG4vKiogT3B0aW9ucyBmb3IgdGhlIG9wZW5FbGVtZW50KCkgdW5pZmllZCBWaXRlIGVudHJ5LiAqL1xuZXhwb3J0IGludGVyZmFjZSBPcGVuRWxlbWVudE9wdGlvbnMgZXh0ZW5kcyBGcmFtZXdvcmtPcHRpb25zIHtcbiAgLyoqIENvbnRlbnQgbW9kdWxlIG9wdGlvbnMgKGJsb2cgKyBuYXYgKyBzaXRlbWFwKS4gT21pdCB0byBkaXNhYmxlLiAqL1xuICBjb250ZW50PzogT3BlbkVsZW1lbnRDb250ZW50T3B0aW9ucztcbiAgLyoqIGkxOG4gbW9kdWxlIG9wdGlvbnMuIE9taXQgdG8gZGlzYWJsZS4gKi9cbiAgaTE4bj86IE9wZW5FbGVtZW50STE4bk9wdGlvbnM7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBvcGVuRWxlbWVudChvcHRpb25zOiBPcGVuRWxlbWVudE9wdGlvbnMgPSB7fSk6IFBsdWdpbltdIHtcbiAgY29uc3QgeyBjb250ZW50OiBjb250ZW50T3B0cywgaTE4bjogaTE4bk9wdHMsIC4uLmNvcmVPcHRzIH0gPSBvcHRpb25zO1xuICBjb25zdCBjdHggPSBuZXcgT3BlbkVsZW1lbnRCdWlsZENvbnRleHQoe1xuICAgIC4uLmNvcmVPcHRzLFxuICAgIHJvdXRlc0RpcjogY29yZU9wdHMucm91dGVzRGlyIHx8ICdhcHAvcm91dGVzJyxcbiAgICBpc2xhbmRzRGlyOiBjb3JlT3B0cy5pc2xhbmRzRGlyIHx8ICdhcHAvaXNsYW5kcycsXG4gICAgY29tcG9uZW50c0RpcjogY29yZU9wdHMuY29tcG9uZW50c0RpciB8fCAnYXBwL2NvbXBvbmVudHMnLFxuICB9KTtcblxuICBjb25zdCBwbHVnaW5zOiBQbHVnaW5bXSA9IFsuLi5jcmVhdGVPcGVuUGx1Z2luKGNvcmVPcHRzLCBjdHgpXTtcblxuICBpZiAoaTE4bk9wdHMpIHtcbiAgICBwbHVnaW5zLnB1c2gob3BlbkkxOG4oeyAuLi5pMThuT3B0cywgY3R4IH0pKTtcbiAgICBsb2cuaW5mbygnaTE4biBwbHVnaW4gbG9hZGVkJyk7XG4gIH1cblxuICBpZiAoY29udGVudE9wdHMpIHtcbiAgICBwbHVnaW5zLnB1c2goLi4ub3BlbkNvbnRlbnQoeyAuLi5jb250ZW50T3B0cywgY3R4IH0pKTtcbiAgICBsb2cuaW5mbygnQ29udGVudCBwbHVnaW4gbG9hZGVkJyk7XG4gIH1cblxuICByZXR1cm4gcGx1Z2lucztcbn1cblxuZXhwb3J0IGRlZmF1bHQgb3BlbkVsZW1lbnQ7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7O0NBS0MsR0FPRCxTQUFTLHVCQUF1QixRQUFRLDRCQUE0QjtBQUNwRSxTQUFTLGdCQUFnQixRQUFRLG1DQUFtQztBQUNwRSxTQUFTLFdBQVcsUUFBUSx1QkFBdUI7QUFDbkQsU0FBUyxRQUFRLFFBQVEsbUJBQW1CO0FBQzVDLFNBQVMsWUFBWSxRQUFRLDJCQUEyQjtBQUV4RCxNQUFNLE1BQU0sYUFBYTtBQVV6QixPQUFPLFNBQVMsWUFBWSxVQUE4QixDQUFDLENBQUM7RUFDMUQsTUFBTSxFQUFFLFNBQVMsV0FBVyxFQUFFLE1BQU0sUUFBUSxFQUFFLEdBQUcsVUFBVSxHQUFHO0VBQzlELE1BQU0sTUFBTSxJQUFJLHdCQUF3QjtJQUN0QyxHQUFHLFFBQVE7SUFDWCxXQUFXLFNBQVMsU0FBUyxJQUFJO0lBQ2pDLFlBQVksU0FBUyxVQUFVLElBQUk7SUFDbkMsZUFBZSxTQUFTLGFBQWEsSUFBSTtFQUMzQztFQUVBLE1BQU0sVUFBb0I7T0FBSSxpQkFBaUIsVUFBVTtHQUFLO0VBRTlELElBQUksVUFBVTtJQUNaLFFBQVEsSUFBSSxDQUFDLFNBQVM7TUFBRSxHQUFHLFFBQVE7TUFBRTtJQUFJO0lBQ3pDLElBQUksSUFBSSxDQUFDO0VBQ1g7RUFFQSxJQUFJLGFBQWE7SUFDZixRQUFRLElBQUksSUFBSSxZQUFZO01BQUUsR0FBRyxXQUFXO01BQUU7SUFBSTtJQUNsRCxJQUFJLElBQUksQ0FBQztFQUNYO0VBRUEsT0FBTztBQUNUO0FBRUEsZUFBZSxZQUFZIn0=