@openelement/ssg 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,21 @@
+# @openelement/ssg
+
+Adapter-agnostic static site generation engine for openElement.
+
+This package owns the build-time SSG pipeline:
+
+- Route scanning and island metadata extraction.
+- Entry descriptor construction and Hono server-entry code generation.
+- Parallel/sequential static page rendering.
+- HTML post-processing, island manifest generation, and SSR admission planning.
+
+`@openelement/ssg` depends on `@openelement/core`, `hono`, and `typescript` — it has no Vite dependency. Generated server entries may import optional packages such as `@openelement/content`, `@openelement/router`, and `@openelement/app` when the consuming project uses those features. Build adapters such as `@openelement/adapter-vite` delegate SSG orchestration to this engine and provide only adapter-specific glue.
+
+Most users should not import this package directly; use the framework entry
+`@openelement/app` or the adapter CLI instead.
+
+## Install
+
+```bash
+npm install @openelement/ssg
+```

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@openelement/ssg",
+  "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"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/open-element/openelement.git"
+  },
+  "keywords": [
+    "openelement",
+    "web-components",
+    "ssg",
+    "framework",
+    "deno"
+  ],
+  "dependencies": {
+    "@openelement/protocol": "^0.41.0-alpha.1",
+    "@openelement/core": "^0.41.0-alpha.1",
+    "@openelement/content": "^0.41.0-alpha.1"
+  }
+}

package/src/build-postprocess.d.ts

@@ -0,0 +1,24 @@
+import type { HydrationStrategy } from '@openelement/protocol/framework';
+import type { IslandDecl } from '@openelement/protocol/ssg';
+/** Narrow view of OpenElementBuildContext used by the SSG post-processor. */ export interface BuildContextView {
+  phase3: {
+    root: string;
+    outDir: string;
+    base: string;
+    upgradeStrategy: HydrationStrategy;
+  };
+  phase1: {
+    islandTagNames: string[];
+    packageIslandDecls: IslandDecl[];
+    islandMeta: Record<string, Partial<IslandDecl>>;
+  };
+}
+/**
+ * Inject the island client script and generate per-page island manifests.
+ * Must only run after Phase 2 (client island build) has completed.
+ */ export declare function postProcessClientIslandBuild(ctx: BuildContextView, scriptSrc: string): Promise<void>;
+/**
+ * Clean Phase 1 SSR artifacts from the public dist directory.
+ * The SSR virtual entry bundle and its source map are build-time only
+ * and must not be deployed to static hosting.
+ */ export declare function cleanSsrArtifacts(ctx: BuildContextView): Promise<void>;

package/src/build-postprocess.js

@@ -0,0 +1,74 @@
+/**
+ * @openelement/ssg - Adapter-agnostic SSG build post-processing.
+ *
+ * Orchestrates client-script injection, island chunk/strategy/layer map
+ * construction, and SSR artifact cleanup. This module has zero Vite
+ * dependency and only reads/writes files.
+ */ import { join } from 'node:path';
+import process from 'node:process';
+import { readdir, unlink } from 'node:fs/promises';
+import { createLogger } from '@openelement/core/logger';
+import { buildIslandChunkMap, injectClientScript } from './postprocess.js';
+import { generateIslandManifests, writeIslandManifests } from './island-manifest.js';
+const log = createLogger('core');
+/**
+ * Inject the island client script and generate per-page island manifests.
+ * Must only run after Phase 2 (client island build) has completed.
+ */ export async function postProcessClientIslandBuild(ctx, scriptSrc) {
+  const root = ctx.phase3.root || process.cwd();
+  const outDir = ctx.phase3.outDir || 'dist';
+  const base = ctx.phase3.base || '/';
+  const outputDir = join(root, outDir);
+  injectClientScript(outputDir, scriptSrc);
+  const islandTagNames = [
+    ...ctx.phase1.islandTagNames || [],
+    ...(ctx.phase1.packageIslandDecls || []).map((island)=>island.tagName)
+  ];
+  const chunkMap = buildIslandChunkMap(root, outDir, islandTagNames, base);
+  const strategyMap = Object.fromEntries([
+    ...Object.entries(ctx.phase1.islandMeta || {}).map(([tag, meta])=>[
+        tag,
+        meta.hydrate || ctx.phase3.upgradeStrategy || 'idle'
+      ]),
+    ...(ctx.phase1.packageIslandDecls || []).map((island)=>[
+        island.tagName,
+        island.hydrate || ctx.phase3.upgradeStrategy || 'idle'
+      ])
+  ]);
+  const layerMap = Object.fromEntries([
+    ...Object.entries(ctx.phase1.islandMeta || {}).map(([tag, meta])=>[
+        tag,
+        meta.hydrate === 'only' || meta.ssr === false ? 'pure-island' : 'dsd-interactive'
+      ]),
+    ...(ctx.phase1.packageIslandDecls || []).map((island)=>[
+        island.tagName,
+        island.hydrate === 'only' || island.ssr === false ? 'pure-island' : 'dsd-interactive'
+      ])
+  ]);
+  const pageManifests = generateIslandManifests(outputDir, chunkMap, strategyMap, layerMap);
+  await writeIslandManifests(outputDir, pageManifests);
+}
+/**
+ * Clean Phase 1 SSR artifacts from the public dist directory.
+ * The SSR virtual entry bundle and its source map are build-time only
+ * and must not be deployed to static hosting.
+ */ export async function cleanSsrArtifacts(ctx) {
+  const root = ctx.phase3.root || process.cwd();
+  const outDir = ctx.phase3.outDir || 'dist';
+  try {
+    const assetsDir = join(root, outDir, 'assets');
+    const entries = await readdir(assetsDir).catch(()=>[]);
+    const toDelete = entries.filter((f)=>f.startsWith('_virtual_open-hono-entry') || f.startsWith('src-') && f.endsWith('.js') && !f.includes('client'));
+    for (const f of toDelete){
+      const p = join(assetsDir, f);
+      await unlink(p).catch(()=>{});
+      log.info(`Cleaned SSR artifact: ${f}`);
+    }
+    if (toDelete.length > 0) {
+      log.info(`Removed ${toDelete.length} unreferenced SSR artifact(s) from dist/assets/`);
+    }
+  } catch  {
+  // Non-critical - assets dir may not exist in some configs
+  }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/ssg/src/build-postprocess.ts"],"sourcesContent":["/**\n * @openelement/ssg - Adapter-agnostic SSG build post-processing.\n *\n * Orchestrates client-script injection, island chunk/strategy/layer map\n * construction, and SSR artifact cleanup. This module has zero Vite\n * dependency and only reads/writes files.\n */\n\nimport { join } from 'node:path';\nimport process from 'node:process';\nimport { readdir, unlink } from 'node:fs/promises';\nimport type { ComponentLayer, HydrationStrategy } from '@openelement/protocol/framework';\nimport type { IslandDecl } from '@openelement/protocol/ssg';\nimport { createLogger } from '@openelement/core/logger';\nimport { buildIslandChunkMap, injectClientScript } from './postprocess.js';\nimport { generateIslandManifests, writeIslandManifests } from './island-manifest.js';\n\nconst log = createLogger('core');\n\n/** Narrow view of OpenElementBuildContext used by the SSG post-processor. */\nexport interface BuildContextView {\n  phase3: {\n    root: string;\n    outDir: string;\n    base: string;\n    upgradeStrategy: HydrationStrategy;\n  };\n  phase1: {\n    islandTagNames: string[];\n    packageIslandDecls: IslandDecl[];\n    islandMeta: Record<string, Partial<IslandDecl>>;\n  };\n}\n\n/**\n * Inject the island client script and generate per-page island manifests.\n * Must only run after Phase 2 (client island build) has completed.\n */\nexport async function postProcessClientIslandBuild(\n  ctx: BuildContextView,\n  scriptSrc: string,\n): Promise<void> {\n  const root = ctx.phase3.root || process.cwd();\n  const outDir = ctx.phase3.outDir || 'dist';\n  const base = ctx.phase3.base || '/';\n  const outputDir = join(root, outDir);\n\n  injectClientScript(outputDir, scriptSrc);\n\n  const islandTagNames = [\n    ...(ctx.phase1.islandTagNames || []),\n    ...(ctx.phase1.packageIslandDecls || []).map((island) => island.tagName),\n  ];\n\n  const chunkMap = buildIslandChunkMap(root, outDir, islandTagNames, base);\n\n  const strategyMap = Object.fromEntries([\n    ...Object.entries(ctx.phase1.islandMeta || {}).map(([tag, meta]) => [\n      tag,\n      meta.hydrate || ctx.phase3.upgradeStrategy || 'idle',\n    ]),\n    ...(ctx.phase1.packageIslandDecls || []).map((island) => [\n      island.tagName,\n      island.hydrate || ctx.phase3.upgradeStrategy || 'idle',\n    ]),\n  ]) as Record<string, HydrationStrategy>;\n\n  const layerMap = Object.fromEntries([\n    ...Object.entries(ctx.phase1.islandMeta || {}).map(([tag, meta]) => [\n      tag,\n      meta.hydrate === 'only' || meta.ssr === false ? 'pure-island' : 'dsd-interactive',\n    ]),\n    ...(ctx.phase1.packageIslandDecls || []).map((island) => [\n      island.tagName,\n      island.hydrate === 'only' || island.ssr === false ? 'pure-island' : 'dsd-interactive',\n    ]),\n  ]) as Record<string, ComponentLayer>;\n\n  const pageManifests = generateIslandManifests(outputDir, chunkMap, strategyMap, layerMap);\n  await writeIslandManifests(outputDir, pageManifests);\n}\n\n/**\n * Clean Phase 1 SSR artifacts from the public dist directory.\n * The SSR virtual entry bundle and its source map are build-time only\n * and must not be deployed to static hosting.\n */\nexport async function cleanSsrArtifacts(ctx: BuildContextView): Promise<void> {\n  const root = ctx.phase3.root || process.cwd();\n  const outDir = ctx.phase3.outDir || 'dist';\n\n  try {\n    const assetsDir = join(root, outDir, 'assets');\n    const entries = await readdir(assetsDir).catch(() => [] as string[]);\n    const toDelete = entries.filter(\n      (f) =>\n        f.startsWith('_virtual_open-hono-entry') ||\n        (f.startsWith('src-') && f.endsWith('.js') && !f.includes('client')),\n    );\n    for (const f of toDelete) {\n      const p = join(assetsDir, f);\n      await unlink(p).catch(() => {});\n      log.info(`Cleaned SSR artifact: ${f}`);\n    }\n    if (toDelete.length > 0) {\n      log.info(`Removed ${toDelete.length} unreferenced SSR artifact(s) from dist/assets/`);\n    }\n  } catch {\n    // Non-critical - assets dir may not exist in some configs\n  }\n}\n"],"names":[],"mappings":"AAAA;;;;;;CAMC,GAED,SAAS,IAAI,QAAQ,YAAY;AACjC,OAAO,aAAa,eAAe;AACnC,SAAS,OAAO,EAAE,MAAM,QAAQ,mBAAmB;AAGnD,SAAS,YAAY,QAAQ,2BAA2B;AACxD,SAAS,mBAAmB,EAAE,kBAAkB,QAAQ,mBAAmB;AAC3E,SAAS,uBAAuB,EAAE,oBAAoB,QAAQ,uBAAuB;AAErF,MAAM,MAAM,aAAa;AAiBzB;;;CAGC,GACD,OAAO,eAAe,6BACpB,GAAqB,EACrB,SAAiB;EAEjB,MAAM,OAAO,IAAI,MAAM,CAAC,IAAI,IAAI,QAAQ,GAAG;EAC3C,MAAM,SAAS,IAAI,MAAM,CAAC,MAAM,IAAI;EACpC,MAAM,OAAO,IAAI,MAAM,CAAC,IAAI,IAAI;EAChC,MAAM,YAAY,KAAK,MAAM;EAE7B,mBAAmB,WAAW;EAE9B,MAAM,iBAAiB;OACjB,IAAI,MAAM,CAAC,cAAc,IAAI,EAAE;OAChC,CAAC,IAAI,MAAM,CAAC,kBAAkB,IAAI,EAAE,EAAE,GAAG,CAAC,CAAC,SAAW,OAAO,OAAO;GACxE;EAED,MAAM,WAAW,oBAAoB,MAAM,QAAQ,gBAAgB;EAEnE,MAAM,cAAc,OAAO,WAAW,CAAC;OAClC,OAAO,OAAO,CAAC,IAAI,MAAM,CAAC,UAAU,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,KAAK,KAAK,GAAK;QAClE;QACA,KAAK,OAAO,IAAI,IAAI,MAAM,CAAC,eAAe,IAAI;OAC/C;OACE,CAAC,IAAI,MAAM,CAAC,kBAAkB,IAAI,EAAE,EAAE,GAAG,CAAC,CAAC,SAAW;QACvD,OAAO,OAAO;QACd,OAAO,OAAO,IAAI,IAAI,MAAM,CAAC,eAAe,IAAI;OACjD;GACF;EAED,MAAM,WAAW,OAAO,WAAW,CAAC;OAC/B,OAAO,OAAO,CAAC,IAAI,MAAM,CAAC,UAAU,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,KAAK,KAAK,GAAK;QAClE;QACA,KAAK,OAAO,KAAK,UAAU,KAAK,GAAG,KAAK,QAAQ,gBAAgB;OACjE;OACE,CAAC,IAAI,MAAM,CAAC,kBAAkB,IAAI,EAAE,EAAE,GAAG,CAAC,CAAC,SAAW;QACvD,OAAO,OAAO;QACd,OAAO,OAAO,KAAK,UAAU,OAAO,GAAG,KAAK,QAAQ,gBAAgB;OACrE;GACF;EAED,MAAM,gBAAgB,wBAAwB,WAAW,UAAU,aAAa;EAChF,MAAM,qBAAqB,WAAW;AACxC;AAEA;;;;CAIC,GACD,OAAO,eAAe,kBAAkB,GAAqB;EAC3D,MAAM,OAAO,IAAI,MAAM,CAAC,IAAI,IAAI,QAAQ,GAAG;EAC3C,MAAM,SAAS,IAAI,MAAM,CAAC,MAAM,IAAI;EAEpC,IAAI;IACF,MAAM,YAAY,KAAK,MAAM,QAAQ;IACrC,MAAM,UAAU,MAAM,QAAQ,WAAW,KAAK,CAAC,IAAM,EAAE;IACvD,MAAM,WAAW,QAAQ,MAAM,CAC7B,CAAC,IACC,EAAE,UAAU,CAAC,+BACZ,EAAE,UAAU,CAAC,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC,EAAE,QAAQ,CAAC;IAE9D,KAAK,MAAM,KAAK,SAAU;MACxB,MAAM,IAAI,KAAK,WAAW;MAC1B,MAAM,OAAO,GAAG,KAAK,CAAC,KAAO;MAC7B,IAAI,IAAI,CAAC,CAAC,sBAAsB,EAAE,GAAG;IACvC;IACA,IAAI,SAAS,MAAM,GAAG,GAAG;MACvB,IAAI,IAAI,CAAC,CAAC,QAAQ,EAAE,SAAS,MAAM,CAAC,+CAA+C,CAAC;IACtF;EACF,EAAE,OAAM;EACN,0DAA0D;EAC5D;AACF"}

package/src/cem-compat.js

@@ -0,0 +1,226 @@
+import { isValidTagName } from '@openelement/core';
+import { formatError } from '@openelement/core/errors';
+function isCemCustomElement(declaration) {
+  return declaration.kind === 'custom-element';
+}
+function isRecord(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function toCemBaseArray(value) {
+  if (!Array.isArray(value)) return undefined;
+  return value.filter(isRecord);
+}
+function toCemExports(value) {
+  if (!Array.isArray(value)) return undefined;
+  return value.filter(isRecord).map((entry)=>({
+      declaration: entry.declaration
+    }));
+}
+function toCemModule(value) {
+  if (!isRecord(value)) return undefined;
+  return {
+    kind: typeof value.kind === 'string' ? value.kind : undefined,
+    path: typeof value.path === 'string' ? value.path : '',
+    declarations: toCemBaseArray(value.declarations),
+    exports: toCemExports(value.exports)
+  };
+}
+export function parseCem(json) {
+  const errors = [];
+  const warnings = [];
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch (error) {
+    errors.push({
+      code: 'CEM_PARSE_ERROR',
+      message: `Invalid JSON: ${formatError(error)}`
+    });
+    return {
+      success: false,
+      errors,
+      warnings
+    };
+  }
+  if (!isRecord(parsed)) {
+    errors.push({
+      code: 'CEM_INVALID_ROOT',
+      message: 'Manifest root must be an object'
+    });
+    return {
+      success: false,
+      errors,
+      warnings
+    };
+  }
+  const root = parsed;
+  if (!root.schemaVersion) {
+    warnings.push({
+      code: 'CEM_NO_SCHEMA_VERSION',
+      message: 'Missing schemaVersion field, assuming legacy format'
+    });
+  }
+  if (!Array.isArray(root.modules)) {
+    errors.push({
+      code: 'CEM_NO_MODULES',
+      message: 'Manifest must have a modules array'
+    });
+    return {
+      success: false,
+      errors,
+      warnings
+    };
+  }
+  const manifest = {
+    ...root,
+    schemaVersion: typeof root.schemaVersion === 'string' ? root.schemaVersion : undefined,
+    packageName: typeof root.packageName === 'string' ? root.packageName : undefined,
+    version: typeof root.version === 'string' ? root.version : undefined,
+    modules: root.modules.map((module)=>toCemModule(module) ?? {
+        path: ''
+      })
+  };
+  const seenTagNames = new Set();
+  for(let i = 0; i < manifest.modules.length; i++){
+    const module = manifest.modules[i];
+    const modulePath = `modules[${i}]`;
+    if (!module.kind) {
+      warnings.push({
+        code: 'CEM_MODULE_NO_KIND',
+        message: `Module at index ${i} has no kind field`,
+        path: modulePath
+      });
+    }
+    if (!module.path) {
+      errors.push({
+        code: 'CEM_MODULE_NO_PATH',
+        message: `Module at index ${i} has no path field`,
+        path: modulePath
+      });
+    }
+    for (const [j, declaration] of (module.declarations ?? []).entries()){
+      if (!isCemCustomElement(declaration)) continue;
+      const declarationPath = `${modulePath}.declarations[${j}]`;
+      const tagName = declaration.tagName;
+      if (!tagName) {
+        errors.push({
+          code: 'CEM_CE_NO_TAG_NAME',
+          message: `Custom element at ${declarationPath} has no tagName`,
+          path: declarationPath
+        });
+      } else if (!isValidTagName(tagName)) {
+        errors.push({
+          code: 'CEM_CE_INVALID_TAG_NAME',
+          message: `Invalid tag name: ${tagName} (must contain a hyphen and match HTML spec)`,
+          path: declarationPath
+        });
+      } else if (seenTagNames.has(tagName)) {
+        errors.push({
+          code: 'CEM_CE_DUPLICATE_TAG',
+          message: `Duplicate tag name: ${tagName}`,
+          path: declarationPath
+        });
+      } else {
+        seenTagNames.add(tagName);
+      }
+    }
+    for (const [j, exported] of (module.exports ?? []).entries()){
+      if (!exported.declaration) {
+        errors.push({
+          code: 'CEM_EXPORT_NO_DECLARATION',
+          message: `Export at ${modulePath}.exports[${j}] has no declaration reference`,
+          path: `${modulePath}.exports[${j}]`
+        });
+      }
+    }
+  }
+  return {
+    success: errors.length === 0,
+    manifest: errors.length === 0 ? manifest : undefined,
+    errors,
+    warnings
+  };
+}
+export function classifyCemManifest(manifest) {
+  const classifications = [];
+  const seenTags = new Map();
+  for (const module of manifest.modules){
+    for (const declaration of module.declarations ?? []){
+      if (!isCemCustomElement(declaration) || !declaration.tagName) continue;
+      if (seenTags.has(declaration.tagName)) {
+        classifications.push({
+          tagName: declaration.tagName,
+          tier: 'rejected',
+          reason: `Duplicate tag name: ${declaration.tagName}`,
+          source: 'package',
+          modulePath: module.path,
+          ssr: false,
+          dsd: false,
+          hydrate: 'idle'
+        });
+        continue;
+      }
+      const classification = classifyCemDeclaration(manifest, module, declaration);
+      classifications.push(classification);
+      seenTags.set(declaration.tagName, classification);
+    }
+  }
+  const rejectedTags = [];
+  const ssrCapableTags = [];
+  const clientOnlyTags = [];
+  const experimentalDomTags = [];
+  // ponytail: bucket lookup replaces 4-case switch
+  const buckets = {
+    rejected: rejectedTags,
+    'ssr-capable': ssrCapableTags,
+    'client-only': clientOnlyTags,
+    'experimental-dom': experimentalDomTags
+  };
+  for (const classification of classifications){
+    buckets[classification.tier]?.push(classification.tagName);
+  }
+  return {
+    classifications,
+    rejectedTags,
+    ssrCapableTags,
+    clientOnlyTags,
+    experimentalDomTags,
+    stats: {
+      totalComponents: classifications.length,
+      ssrCapableCount: ssrCapableTags.length,
+      clientOnlyCount: clientOnlyTags.length,
+      rejectedCount: rejectedTags.length,
+      experimentalDomCount: experimentalDomTags.length
+    }
+  };
+}
+function classifyCemDeclaration(manifest, module, declaration) {
+  const openElement = declaration.openElement;
+  const ssr = openElement?.ssr ?? false;
+  const dsd = openElement?.dsd ?? false;
+  const hydrate = openElement?.hydrate ?? 'idle';
+  let tier = 'client-only';
+  let reason = manifest.packageName ? `CEM-only package ${manifest.packageName} (no openElement SSR declaration)` : 'CEM-only package (no openElement SSR declaration)';
+  if (openElement?.ssr === true) {
+    if (openElement.layer) {
+      tier = 'ssr-capable';
+      reason = `ssr: true with layer: ${openElement.layer}`;
+    } else {
+      tier = 'client-only';
+      reason = 'ssr: true but no adapter/layer declared';
+    }
+  } else if (openElement?.ssr === false) {
+    reason = 'ssr: false (explicit client-only)';
+  }
+  return {
+    tagName: declaration.tagName,
+    tier,
+    reason,
+    source: 'package',
+    modulePath: module.path,
+    ssr,
+    dsd,
+    hydrate
+  };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/ssg/src/cem-compat.ts"],"sourcesContent":["import type {\n  CompatibilityClassification,\n  CompatibilityTier,\n  HydrationStrategy,\n} from '@openelement/protocol/framework';\nimport { isValidTagName } from '@openelement/core';\nimport { formatError } from '@openelement/core/errors';\n\nexport interface OpenElementExtensions {\n  ssr?: boolean;\n  dsd?: boolean;\n  layer?: string;\n  hydrate?: HydrationStrategy;\n  module?: string;\n  export?: string;\n}\n\ninterface CemBase {\n  kind?: string;\n  [key: string]: unknown;\n}\n\ninterface CemCustomElement extends CemBase {\n  kind: 'custom-element';\n  tagName?: string;\n  superClass?: { name?: string };\n  openElement?: OpenElementExtensions;\n}\n\ninterface CemModule {\n  kind?: string;\n  path: string;\n  declarations?: CemBase[];\n  exports?: { declaration?: unknown }[];\n}\n\nexport interface CustomElementsManifest {\n  schemaVersion?: string;\n  packageName?: string;\n  version?: string;\n  modules: CemModule[];\n  [key: string]: unknown;\n}\n\nexport interface CemParseError {\n  code: string;\n  message: string;\n  path?: string;\n}\n\nexport interface CemParseWarning {\n  code: string;\n  message: string;\n  path?: string;\n}\n\nexport interface CemParseResult {\n  success: boolean;\n  manifest?: CustomElementsManifest;\n  errors: CemParseError[];\n  warnings: CemParseWarning[];\n}\n\nexport interface CemClassificationResult {\n  classifications: CompatibilityClassification[];\n  rejectedTags: string[];\n  ssrCapableTags: string[];\n  clientOnlyTags: string[];\n  experimentalDomTags: string[];\n  stats: {\n    totalComponents: number;\n    ssrCapableCount: number;\n    clientOnlyCount: number;\n    rejectedCount: number;\n    experimentalDomCount: number;\n  };\n}\n\nfunction isCemCustomElement(declaration: CemBase): declaration is CemCustomElement {\n  return declaration.kind === 'custom-element';\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return !!value && typeof value === 'object' && !Array.isArray(value);\n}\n\nfunction toCemBaseArray(value: unknown): CemBase[] | undefined {\n  if (!Array.isArray(value)) return undefined;\n  return value.filter(isRecord);\n}\n\nfunction toCemExports(value: unknown): { declaration?: unknown }[] | undefined {\n  if (!Array.isArray(value)) return undefined;\n  return value.filter(isRecord).map((entry) => ({ declaration: entry.declaration }));\n}\n\nfunction toCemModule(value: unknown): CemModule | undefined {\n  if (!isRecord(value)) return undefined;\n  return {\n    kind: typeof value.kind === 'string' ? value.kind : undefined,\n    path: typeof value.path === 'string' ? value.path : '',\n    declarations: toCemBaseArray(value.declarations),\n    exports: toCemExports(value.exports),\n  };\n}\n\nexport function parseCem(json: string): CemParseResult {\n  const errors: CemParseError[] = [];\n  const warnings: CemParseWarning[] = [];\n\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(json);\n  } catch (error) {\n    errors.push({\n      code: 'CEM_PARSE_ERROR',\n      message: `Invalid JSON: ${formatError(error)}`,\n    });\n    return { success: false, errors, warnings };\n  }\n\n  if (!isRecord(parsed)) {\n    errors.push({ code: 'CEM_INVALID_ROOT', message: 'Manifest root must be an object' });\n    return { success: false, errors, warnings };\n  }\n\n  const root = parsed;\n  if (!root.schemaVersion) {\n    warnings.push({\n      code: 'CEM_NO_SCHEMA_VERSION',\n      message: 'Missing schemaVersion field, assuming legacy format',\n    });\n  }\n  if (!Array.isArray(root.modules)) {\n    errors.push({ code: 'CEM_NO_MODULES', message: 'Manifest must have a modules array' });\n    return { success: false, errors, warnings };\n  }\n\n  const manifest: CustomElementsManifest = {\n    ...root,\n    schemaVersion: typeof root.schemaVersion === 'string' ? root.schemaVersion : undefined,\n    packageName: typeof root.packageName === 'string' ? root.packageName : undefined,\n    version: typeof root.version === 'string' ? root.version : undefined,\n    modules: root.modules.map((module) =>\n      toCemModule(module) ?? {\n        path: '',\n      }\n    ),\n  };\n  const seenTagNames = new Set<string>();\n\n  for (let i = 0; i < manifest.modules.length; i++) {\n    const module = manifest.modules[i];\n    const modulePath = `modules[${i}]`;\n\n    if (!module.kind) {\n      warnings.push({\n        code: 'CEM_MODULE_NO_KIND',\n        message: `Module at index ${i} has no kind field`,\n        path: modulePath,\n      });\n    }\n    if (!module.path) {\n      errors.push({\n        code: 'CEM_MODULE_NO_PATH',\n        message: `Module at index ${i} has no path field`,\n        path: modulePath,\n      });\n    }\n\n    for (const [j, declaration] of (module.declarations ?? []).entries()) {\n      if (!isCemCustomElement(declaration)) continue;\n      const declarationPath = `${modulePath}.declarations[${j}]`;\n      const tagName = declaration.tagName;\n      if (!tagName) {\n        errors.push({\n          code: 'CEM_CE_NO_TAG_NAME',\n          message: `Custom element at ${declarationPath} has no tagName`,\n          path: declarationPath,\n        });\n      } else if (!isValidTagName(tagName)) {\n        errors.push({\n          code: 'CEM_CE_INVALID_TAG_NAME',\n          message: `Invalid tag name: ${tagName} (must contain a hyphen and match HTML spec)`,\n          path: declarationPath,\n        });\n      } else if (seenTagNames.has(tagName)) {\n        errors.push({\n          code: 'CEM_CE_DUPLICATE_TAG',\n          message: `Duplicate tag name: ${tagName}`,\n          path: declarationPath,\n        });\n      } else {\n        seenTagNames.add(tagName);\n      }\n    }\n\n    for (const [j, exported] of (module.exports ?? []).entries()) {\n      if (!exported.declaration) {\n        errors.push({\n          code: 'CEM_EXPORT_NO_DECLARATION',\n          message: `Export at ${modulePath}.exports[${j}] has no declaration reference`,\n          path: `${modulePath}.exports[${j}]`,\n        });\n      }\n    }\n  }\n\n  return {\n    success: errors.length === 0,\n    manifest: errors.length === 0 ? manifest : undefined,\n    errors,\n    warnings,\n  };\n}\n\nexport function classifyCemManifest(manifest: CustomElementsManifest): CemClassificationResult {\n  const classifications: CompatibilityClassification[] = [];\n  const seenTags = new Map<string, CompatibilityClassification>();\n\n  for (const module of manifest.modules) {\n    for (const declaration of module.declarations ?? []) {\n      if (!isCemCustomElement(declaration) || !declaration.tagName) continue;\n\n      if (seenTags.has(declaration.tagName)) {\n        classifications.push({\n          tagName: declaration.tagName,\n          tier: 'rejected',\n          reason: `Duplicate tag name: ${declaration.tagName}`,\n          source: 'package',\n          modulePath: module.path,\n          ssr: false,\n          dsd: false,\n          hydrate: 'idle',\n        });\n        continue;\n      }\n\n      const classification = classifyCemDeclaration(manifest, module, declaration);\n      classifications.push(classification);\n      seenTags.set(declaration.tagName, classification);\n    }\n  }\n\n  const rejectedTags: string[] = [];\n  const ssrCapableTags: string[] = [];\n  const clientOnlyTags: string[] = [];\n  const experimentalDomTags: string[] = [];\n\n  // ponytail: bucket lookup replaces 4-case switch\n  const buckets: Record<string, string[]> = {\n    rejected: rejectedTags,\n    'ssr-capable': ssrCapableTags,\n    'client-only': clientOnlyTags,\n    'experimental-dom': experimentalDomTags,\n  };\n\n  for (const classification of classifications) {\n    buckets[classification.tier]?.push(classification.tagName);\n  }\n\n  return {\n    classifications,\n    rejectedTags,\n    ssrCapableTags,\n    clientOnlyTags,\n    experimentalDomTags,\n    stats: {\n      totalComponents: classifications.length,\n      ssrCapableCount: ssrCapableTags.length,\n      clientOnlyCount: clientOnlyTags.length,\n      rejectedCount: rejectedTags.length,\n      experimentalDomCount: experimentalDomTags.length,\n    },\n  };\n}\n\nfunction classifyCemDeclaration(\n  manifest: CustomElementsManifest,\n  module: CemModule,\n  declaration: CemCustomElement,\n): CompatibilityClassification {\n  const openElement = declaration.openElement;\n  const ssr = openElement?.ssr ?? false;\n  const dsd = openElement?.dsd ?? false;\n  const hydrate = openElement?.hydrate ?? 'idle';\n\n  let tier: CompatibilityTier = 'client-only';\n  let reason = manifest.packageName\n    ? `CEM-only package ${manifest.packageName} (no openElement SSR declaration)`\n    : 'CEM-only package (no openElement SSR declaration)';\n\n  if (openElement?.ssr === true) {\n    if (openElement.layer) {\n      tier = 'ssr-capable';\n      reason = `ssr: true with layer: ${openElement.layer}`;\n    } else {\n      tier = 'client-only';\n      reason = 'ssr: true but no adapter/layer declared';\n    }\n  } else if (openElement?.ssr === false) {\n    reason = 'ssr: false (explicit client-only)';\n  }\n\n  return {\n    tagName: declaration.tagName!,\n    tier,\n    reason,\n    source: 'package',\n    modulePath: module.path,\n    ssr,\n    dsd,\n    hydrate,\n  };\n}\n"],"names":[],"mappings":"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"}

package/src/entry-generators.d.ts

@@ -0,0 +1,3 @@
+import type { ClientIslandEntry } from '@openelement/protocol/ssg';
+export declare function validateClientIslandEntry(entry: ClientIslandEntry): void;
+export declare function generateClientEntry(islands: ClientIslandEntry[]): string;

package/src/entry-generators.js

@@ -0,0 +1,126 @@
+/**
+ * @openelement/core - Entry Generators
+ *
+ * v0.21.0: manifest-driven hydration strategies.
+ * Zero DOM interaction - cannot interfere with DSD rendering.
+ */ const CUSTOM_ELEMENT_NAME_RE = /^[a-z][.0-9_a-z]*-[\-.0-9_a-z]*$/;
+const UNSAFE_IMPORT_PROTOCOL_RE = /^(?:javascript|data|vbscript|node):/i;
+const VALID_STRATEGIES = new Set([
+  'load',
+  'idle',
+  'visible',
+  'only'
+]);
+function hasControlCharacter(value) {
+  for(let i = 0; i < value.length; i++){
+    const code = value.charCodeAt(i);
+    if (code <= 0x1f || code === 0x7f) return true;
+  }
+  return false;
+}
+export function validateClientIslandEntry(entry) {
+  if (!CUSTOM_ELEMENT_NAME_RE.test(entry.tagName)) {
+    throw new Error(`Invalid island tagName: ${entry.tagName}`);
+  }
+  if (!entry.modulePath || hasControlCharacter(entry.modulePath) || /[\r\n]/.test(entry.modulePath) || UNSAFE_IMPORT_PROTOCOL_RE.test(entry.modulePath)) {
+    throw new Error(`Invalid island modulePath for ${entry.tagName}: ${entry.modulePath}`);
+  }
+  if (!VALID_STRATEGIES.has(entry.strategy)) {
+    throw new Error(`Invalid island strategy for ${entry.tagName}: ${String(entry.strategy)}. ` + 'Use one of: load, idle, visible, only.');
+  }
+}
+export function generateClientEntry(islands) {
+  islands.forEach(validateClientIslandEntry);
+  if (islands.length === 0) {
+    return '// openElement Client Entry - No islands detected, zero client JS needed\n';
+  }
+  const islandMap = islands.map((i)=>`  ${JSON.stringify(i.tagName)}: () => import(${JSON.stringify(i.modulePath)})`).join(',\n');
+  const tags = islands.map((i)=>JSON.stringify(i.tagName)).join(', ');
+  const loadTags = islands.filter((i)=>i.strategy === 'load').map((i)=>JSON.stringify(i.tagName)).join(', ');
+  const visibleTags = islands.filter((i)=>i.strategy === 'visible').map((i)=>JSON.stringify(i.tagName)).join(', ');
+  const idleTags = islands.filter((i)=>i.strategy === 'idle').map((i)=>JSON.stringify(i.tagName)).join(', ');
+  const onlyTags = islands.filter((i)=>i.strategy === 'only').map((i)=>JSON.stringify(i.tagName)).join(', ');
+  return `// openElement Client Entry (v0.21 - load/idle/visible/only)
+// load islands import immediately.
+// idle islands import during browser idle time.
+// visible islands import when their host enters the viewport.
+// only islands are client-only and import immediately (no DSD/SSR).
+// Zero DOM interaction - safe with DSD rendering.
+
+var log = {
+  warn: function() { var a = ['[openElement]']; a.push.apply(a, arguments); console.warn.apply(console, a); },
+  error: function() { var a = ['[openElement]']; a.push.apply(a, arguments); console.error.apply(console, a); },
+};
+
+var __map = {
+${islandMap}
+};
+var __tags = [${tags}];
+
+function __load(tag) {
+  if (__map[tag]) {
+    __map[tag]().catch(function(e) { log.warn(tag, e); });
+    __map[tag] = null;
+  }
+}
+
+function __onReady(fn) {
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', fn, { once: true });
+  } else {
+    fn();
+  }
+}
+
+function __dispatchReady(strategy, tags) {
+  document.dispatchEvent(new CustomEvent('open:ready', {
+    detail: { strategy: strategy, islands: tags }
+  }));
+}
+
+// client:load islands - import immediately
+[${loadTags || ''}].filter(Boolean).forEach(__load);
+
+// client:only islands - import immediately, no DSD/SSR expected
+${onlyTags ? `var __onlyTags = [${onlyTags || ''}];\n__onlyTags.forEach(__load);\n` : '// No client:only islands\n'}
+// client:visible islands - load when their element enters viewport
+${visibleTags ? `var __visibleTags = [${visibleTags || ''}];
+var __observedTags = [];
+function __observeVisible() {
+  if (!('IntersectionObserver' in window)) {
+    __visibleTags.forEach(__load);
+    __dispatchReady('visible', __visibleTags);
+    return;
+  }
+  __visibleTags.forEach(function(tag) {
+    var els = document.querySelectorAll(tag);
+    if (els.length > 0 && __observedTags.indexOf(tag) === -1) {
+      __observedTags.push(tag);
+      els.forEach(function(el) {
+        var obs = new IntersectionObserver(function(entries) {
+          entries.forEach(function(entry) {
+            if (entry.isIntersecting) {
+              __load(tag);
+              __dispatchReady('visible', [tag]);
+              obs.disconnect();
+            }
+          });
+        }, { rootMargin: '200px' });
+        obs.observe(el);
+      });
+    }
+  });
+}
+__onReady(__observeVisible);` : '// No client:visible islands'}
+
+// client:idle islands - defer to browser idle
+${idleTags ? `var __idleTags = [${idleTags || ''}];
+var __deferred = function() {
+  __idleTags.forEach(__load);
+  __dispatchReady('idle', __idleTags);
+};
+var __schedule = window.requestIdleCallback || window.requestAnimationFrame || function(fn) { setTimeout(fn, 50); };
+__schedule(__deferred);` : '// No client:idle islands'}
+`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/ssg/src/entry-generators.ts"],"sourcesContent":["/**\n * @openelement/core - Entry Generators\n *\n * v0.21.0: manifest-driven hydration strategies.\n * Zero DOM interaction - cannot interfere with DSD rendering.\n */\n\nimport type { HydrationStrategy } from '@openelement/protocol/framework';\nimport type { ClientIslandEntry } from '@openelement/protocol/ssg';\n\nconst CUSTOM_ELEMENT_NAME_RE = /^[a-z][.0-9_a-z]*-[\\-.0-9_a-z]*$/;\nconst UNSAFE_IMPORT_PROTOCOL_RE = /^(?:javascript|data|vbscript|node):/i;\nconst VALID_STRATEGIES = new Set<HydrationStrategy>(['load', 'idle', 'visible', 'only']);\n\nfunction hasControlCharacter(value: string): boolean {\n  for (let i = 0; i < value.length; i++) {\n    const code = value.charCodeAt(i);\n    if (code <= 0x1f || code === 0x7f) return true;\n  }\n  return false;\n}\n\nexport function validateClientIslandEntry(entry: ClientIslandEntry): void {\n  if (!CUSTOM_ELEMENT_NAME_RE.test(entry.tagName)) {\n    throw new Error(`Invalid island tagName: ${entry.tagName}`);\n  }\n  if (\n    !entry.modulePath ||\n    hasControlCharacter(entry.modulePath) ||\n    /[\\r\\n]/.test(entry.modulePath) ||\n    UNSAFE_IMPORT_PROTOCOL_RE.test(entry.modulePath)\n  ) {\n    throw new Error(`Invalid island modulePath for ${entry.tagName}: ${entry.modulePath}`);\n  }\n  if (!VALID_STRATEGIES.has(entry.strategy)) {\n    throw new Error(\n      `Invalid island strategy for ${entry.tagName}: ${String(entry.strategy)}. ` +\n        'Use one of: load, idle, visible, only.',\n    );\n  }\n}\n\nexport function generateClientEntry(\n  islands: ClientIslandEntry[],\n): string {\n  islands.forEach(validateClientIslandEntry);\n\n  if (islands.length === 0) {\n    return '// openElement Client Entry - No islands detected, zero client JS needed\\n';\n  }\n\n  const islandMap = islands\n    .map((i) => `  ${JSON.stringify(i.tagName)}: () => import(${JSON.stringify(i.modulePath)})`)\n    .join(',\\n');\n\n  const tags = islands.map((i) => JSON.stringify(i.tagName)).join(', ');\n  const loadTags = islands\n    .filter((i) => i.strategy === 'load')\n    .map((i) => JSON.stringify(i.tagName))\n    .join(', ');\n  const visibleTags = islands\n    .filter((i) => i.strategy === 'visible')\n    .map((i) => JSON.stringify(i.tagName))\n    .join(', ');\n  const idleTags = islands\n    .filter((i) => i.strategy === 'idle')\n    .map((i) => JSON.stringify(i.tagName))\n    .join(', ');\n  const onlyTags = islands\n    .filter((i) => i.strategy === 'only')\n    .map((i) => JSON.stringify(i.tagName))\n    .join(', ');\n\n  return `// openElement Client Entry (v0.21 - load/idle/visible/only)\n// load islands import immediately.\n// idle islands import during browser idle time.\n// visible islands import when their host enters the viewport.\n// only islands are client-only and import immediately (no DSD/SSR).\n// Zero DOM interaction - safe with DSD rendering.\n\nvar log = {\n  warn: function() { var a = ['[openElement]']; a.push.apply(a, arguments); console.warn.apply(console, a); },\n  error: function() { var a = ['[openElement]']; a.push.apply(a, arguments); console.error.apply(console, a); },\n};\n\nvar __map = {\n${islandMap}\n};\nvar __tags = [${tags}];\n\nfunction __load(tag) {\n  if (__map[tag]) {\n    __map[tag]().catch(function(e) { log.warn(tag, e); });\n    __map[tag] = null;\n  }\n}\n\nfunction __onReady(fn) {\n  if (document.readyState === 'loading') {\n    document.addEventListener('DOMContentLoaded', fn, { once: true });\n  } else {\n    fn();\n  }\n}\n\nfunction __dispatchReady(strategy, tags) {\n  document.dispatchEvent(new CustomEvent('open:ready', {\n    detail: { strategy: strategy, islands: tags }\n  }));\n}\n\n// client:load islands - import immediately\n[${loadTags || ''}].filter(Boolean).forEach(__load);\n\n// client:only islands - import immediately, no DSD/SSR expected\n${\n    onlyTags\n      ? `var __onlyTags = [${onlyTags || ''}];\\n__onlyTags.forEach(__load);\\n`\n      : '// No client:only islands\\n'\n  }\n// client:visible islands - load when their element enters viewport\n${\n    visibleTags\n      ? `var __visibleTags = [${visibleTags || ''}];\nvar __observedTags = [];\nfunction __observeVisible() {\n  if (!('IntersectionObserver' in window)) {\n    __visibleTags.forEach(__load);\n    __dispatchReady('visible', __visibleTags);\n    return;\n  }\n  __visibleTags.forEach(function(tag) {\n    var els = document.querySelectorAll(tag);\n    if (els.length > 0 && __observedTags.indexOf(tag) === -1) {\n      __observedTags.push(tag);\n      els.forEach(function(el) {\n        var obs = new IntersectionObserver(function(entries) {\n          entries.forEach(function(entry) {\n            if (entry.isIntersecting) {\n              __load(tag);\n              __dispatchReady('visible', [tag]);\n              obs.disconnect();\n            }\n          });\n        }, { rootMargin: '200px' });\n        obs.observe(el);\n      });\n    }\n  });\n}\n__onReady(__observeVisible);`\n      : '// No client:visible islands'\n  }\n\n// client:idle islands - defer to browser idle\n${\n    idleTags\n      ? `var __idleTags = [${idleTags || ''}];\nvar __deferred = function() {\n  __idleTags.forEach(__load);\n  __dispatchReady('idle', __idleTags);\n};\nvar __schedule = window.requestIdleCallback || window.requestAnimationFrame || function(fn) { setTimeout(fn, 50); };\n__schedule(__deferred);`\n      : '// No client:idle islands'\n  }\n`;\n}\n"],"names":[],"mappings":"AAAA;;;;;CAKC,GAKD,MAAM,yBAAyB;AAC/B,MAAM,4BAA4B;AAClC,MAAM,mBAAmB,IAAI,IAAuB;EAAC;EAAQ;EAAQ;EAAW;CAAO;AAEvF,SAAS,oBAAoB,KAAa;EACxC,IAAK,IAAI,IAAI,GAAG,IAAI,MAAM,MAAM,EAAE,IAAK;IACrC,MAAM,OAAO,MAAM,UAAU,CAAC;IAC9B,IAAI,QAAQ,QAAQ,SAAS,MAAM,OAAO;EAC5C;EACA,OAAO;AACT;AAEA,OAAO,SAAS,0BAA0B,KAAwB;EAChE,IAAI,CAAC,uBAAuB,IAAI,CAAC,MAAM,OAAO,GAAG;IAC/C,MAAM,IAAI,MAAM,CAAC,wBAAwB,EAAE,MAAM,OAAO,EAAE;EAC5D;EACA,IACE,CAAC,MAAM,UAAU,IACjB,oBAAoB,MAAM,UAAU,KACpC,SAAS,IAAI,CAAC,MAAM,UAAU,KAC9B,0BAA0B,IAAI,CAAC,MAAM,UAAU,GAC/C;IACA,MAAM,IAAI,MAAM,CAAC,8BAA8B,EAAE,MAAM,OAAO,CAAC,EAAE,EAAE,MAAM,UAAU,EAAE;EACvF;EACA,IAAI,CAAC,iBAAiB,GAAG,CAAC,MAAM,QAAQ,GAAG;IACzC,MAAM,IAAI,MACR,CAAC,4BAA4B,EAAE,MAAM,OAAO,CAAC,EAAE,EAAE,OAAO,MAAM,QAAQ,EAAE,EAAE,CAAC,GACzE;EAEN;AACF;AAEA,OAAO,SAAS,oBACd,OAA4B;EAE5B,QAAQ,OAAO,CAAC;EAEhB,IAAI,QAAQ,MAAM,KAAK,GAAG;IACxB,OAAO;EACT;EAEA,MAAM,YAAY,QACf,GAAG,CAAC,CAAC,IAAM,CAAC,EAAE,EAAE,KAAK,SAAS,CAAC,EAAE,OAAO,EAAE,eAAe,EAAE,KAAK,SAAS,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC,EAC1F,IAAI,CAAC;EAER,MAAM,OAAO,QAAQ,GAAG,CAAC,CAAC,IAAM,KAAK,SAAS,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;EAChE,MAAM,WAAW,QACd,MAAM,CAAC,CAAC,IAAM,EAAE,QAAQ,KAAK,QAC7B,GAAG,CAAC,CAAC,IAAM,KAAK,SAAS,CAAC,EAAE,OAAO,GACnC,IAAI,CAAC;EACR,MAAM,cAAc,QACjB,MAAM,CAAC,CAAC,IAAM,EAAE,QAAQ,KAAK,WAC7B,GAAG,CAAC,CAAC,IAAM,KAAK,SAAS,CAAC,EAAE,OAAO,GACnC,IAAI,CAAC;EACR,MAAM,WAAW,QACd,MAAM,CAAC,CAAC,IAAM,EAAE,QAAQ,KAAK,QAC7B,GAAG,CAAC,CAAC,IAAM,KAAK,SAAS,CAAC,EAAE,OAAO,GACnC,IAAI,CAAC;EACR,MAAM,WAAW,QACd,MAAM,CAAC,CAAC,IAAM,EAAE,QAAQ,KAAK,QAC7B,GAAG,CAAC,CAAC,IAAM,KAAK,SAAS,CAAC,EAAE,OAAO,GACnC,IAAI,CAAC;EAER,OAAO,CAAC;;;;;;;;;;;;;AAaV,EAAE,UAAU;;cAEE,EAAE,KAAK;;;;;;;;;;;;;;;;;;;;;;;;CAwBpB,EAAE,YAAY,GAAG;;;AAGlB,EACI,WACI,CAAC,kBAAkB,EAAE,YAAY,GAAG,iCAAiC,CAAC,GACtE,8BACL;;AAEH,EACI,cACI,CAAC,qBAAqB,EAAE,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;4BA2BtB,CAAC,GACrB,+BACL;;;AAGH,EACI,WACI,CAAC,kBAAkB,EAAE,YAAY,GAAG;;;;;;uBAMrB,CAAC,GAChB,4BACL;AACH,CAAC;AACD"}