@openelement/create 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,33 @@
+# @openelement/create
+
+Project scaffolding CLI for openElement applications.
+
+> v0.39 surface: Framework product entry. This package is part of the
+> first-run Framework story alongside `@openelement/app` and
+> `@openelement/app/vite`.
+
+`@openelement/create` generates a new openElement project with the recommended
+directory structure, Deno configuration, Vite setup, and starter pages.
+
+## Usage
+
+```bash
+deno run -A npm:@openelement/create my-app
+cd my-app
+deno task dev
+```
+
+## What It Creates
+
+- `deno.json` - starter authoring imports and build tasks
+- `vite.config.ts` - Vite build configuration with the openElement plugin
+- `app/` - application directory with starter pages and islands
+- `www/` - website output directory
+
+The generated import map intentionally keeps protocol and build internals out of
+the starter surface. Advanced contracts remain available through the published
+workspace packages when a project needs them.
+
+## License
+
+MIT

package/cli.js

@@ -0,0 +1,397 @@
+import { Deno } from "@deno/shim-deno";
+/**
+ * @openelement/create - Minimal project scaffold for openElement framework.
+ *
+ * Usage: deno run -A npm:@openelement/create my-app
+ *
+ * openElement Architecture: Keep It Simple, Stupid.
+ * One template, zero prompts, instant start.
+ */ import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createLogger } from '@openelement/core/logger';
+// ??? Package versions ??????????????????????????????????????????
+// ADR 0016: Handle both local (workspace file://) and remote (npm registry) execution.
+//
+// - Local:  read version from workspace deno.json (single source of truth)
+// - Remote: query npm Registry API for latest version (zero hardcoding)
+const NPM_SCOPE = '@openelement';
+const log = createLogger('create');
+const PKG_DIR_MAP = {
+  core: 'core',
+  adapterVite: 'adapter-vite',
+  app: 'app',
+  content: 'content',
+  ui: 'ui',
+  signal: 'signal',
+  element: 'element'
+};
+function loadWorkspaceVersion(pkg) {
+  const metaUrl = import.meta.url;
+  const selfPath = fileURLToPath(new URL('.', metaUrl));
+  const dir = PKG_DIR_MAP[pkg] || pkg;
+  const wsPath = resolve(selfPath, '..', '..', 'packages', dir, 'deno.json');
+  try {
+    const version = JSON.parse(Deno.readTextFileSync(wsPath)).version;
+    if (!version) throw new Error(`No version found in ${wsPath}`);
+    return version;
+  } catch (e) {
+    throw new Error(`Failed to read version for @openelement/${dir} from ${wsPath}. ` + `Run this script from the openElement workspace or ensure deno.json is accessible.\n` + `Original error: ${e}`);
+  }
+}
+/** Detect whether cli.ts is being run from the openElement workspace. */ function isWorkspace() {
+  try {
+    const selfPath = fileURLToPath(new URL('.', import.meta.url));
+    Deno.readTextFileSync(resolve(selfPath, '..', '..', 'packages', 'core', 'deno.json'));
+    return true;
+  } catch  {
+    return false;
+  }
+}
+/** Fetch the latest version of an npm package from the Registry API. */ async function fetchNpmVersion(pkg) {
+  const resp = await fetch(`https://registry.npmjs.org/${NPM_SCOPE}/${pkg}`, {
+    headers: {
+      Accept: 'application/json'
+    }
+  });
+  if (!resp.ok) {
+    throw new Error(`Failed to fetch version for ${NPM_SCOPE}/${pkg} from npm registry (HTTP ${resp.status})`);
+  }
+  const meta = await resp.json();
+  // npm registry response has dist-tags.latest
+  const version = meta?.['dist-tags']?.latest;
+  if (!version) {
+    throw new Error(`No version found for ${NPM_SCOPE}/${pkg} in npm registry response`);
+  }
+  return version;
+}
+/** Resolve all package versions: local from workspace, remote from npm registry. */ async function resolveVersions() {
+  const keys = Object.keys(PKG_DIR_MAP);
+  if (isWorkspace()) {
+    // Local: synchronous read from workspace
+    const v = {};
+    for (const k of keys)v[k] = loadWorkspaceVersion(k);
+    return v;
+  }
+  // Remote: fetch all versions from npm in parallel
+  console.info('Resolving package versions from npm...');
+  const entries = await Promise.all(keys.map(async (k)=>[
+      k,
+      await fetchNpmVersion(PKG_DIR_MAP[k])
+    ]));
+  return Object.fromEntries(entries);
+}
+/** Build the template map with resolved version numbers. */ function buildTemplates(v) {
+  return {
+    '.gitignore': `dist/
+node_modules/
+`,
+    'public/openelement-mark.svg': `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 96 96" role="img" aria-label="openElement mark">
+  <rect width="96" height="96" rx="18" fill="#212529"/>
+  <path d="M26 58V38l22-13 22 13v20L48 71 26 58Z" fill="none" stroke="#f8f9fa" stroke-width="6" stroke-linejoin="round"/>
+  <path d="M36 48h24" stroke="#7cc7ff" stroke-width="6" stroke-linecap="round"/>
+</svg>
+`,
+    'deno.json': `{
+  "imports": {
+    "@preact/signals-core": "npm:@preact/signals-core@^1.12.1",
+    "@deno/vite-plugin": "npm:@deno/vite-plugin",
+    "entities": "npm:entities@^4.5.0",
+    "hono": "npm:hono@4.12.23",
+    "hono/cors": "npm:hono@4.12.23/cors",
+    "hono/logger": "npm:hono@4.12.23/logger",
+    "hono/request-id": "npm:hono@4.12.23/request-id",
+    "hono/secure-headers": "npm:hono@4.12.23/secure-headers",
+    "marked": "npm:marked@15.0.12",
+    "@openelement/app": "npm:@openelement/app@^${v.app}",
+    "@openelement/app/vite": "npm:@openelement/app@^${v.app}/vite",
+    "@openelement/core": "npm:@openelement/core@^${v.core}",
+    "@openelement/core/jsx-runtime": "npm:@openelement/core@^${v.core}/jsx-runtime",
+    "@openelement/element": "npm:@openelement/element@^${v.element}",
+    "@openelement/ui": "npm:@openelement/ui@^${v.ui}",
+    "vite": "npm:vite@8.0.10"
+  },
+  "nodeModulesDir": "auto",
+  "tasks": {
+    "dev": "deno run --config deno.json -A npm:vite",
+    "build": "deno run --config deno.json -A npm:@openelement/adapter-vite@^${v.adapterVite}/cli/build",
+    "build:ssr": "deno run --config deno.json -A npm:vite build",
+    "build:client": "deno run --config deno.json -A npm:@openelement/adapter-vite@^${v.adapterVite}/cli/build-client",
+    "build:ssg": "deno run --config deno.json -A npm:@openelement/adapter-vite@^${v.adapterVite}/cli/build-ssg",
+    "preview": "deno run --config deno.json -A npm:vite preview"
+  },
+  "compilerOptions": { "lib": ["ES2022", "DOM", "DOM.Iterable"], "jsx": "react-jsx", "jsxImportSource": "@openelement/core" }
+}
+`,
+    'vite.config.ts': `import { openElement } from '@openelement/app/vite';
+import { defineConfig } from 'vite';
+import deno from '@deno/vite-plugin';
+
+// Design tokens (from Open Props)
+const colorTokensStyle =
+  '<style>' +
+  '--gray-0:#f8f9fa;--gray-1:#f1f3f5;--gray-3:#dee2e6;--gray-5:#adb5bd;--gray-7:#495057;--gray-9:#212529;' +
+  '--brand:#534ab7;--size-1:4px;--size-2:8px;--size-3:12px;--size-4:16px;--border-size-1:1px;--radius-2:8px;' +
+  '--font-sans:system-ui,-apple-system,sans-serif;--font-size-0:0.875rem;--font-weight-5:500;' +
+  '--shadow-1:0 1px 3px 0 rgb(0 0 0 / 0.1);' +
+  'body{margin:0;background:var(--gray-1);color:var(--gray-9);font-family:var(--font-sans);-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}</style>';
+
+export default defineConfig({
+  plugins: [
+    // SOP-015: Virtual module passthrough — @deno/vite-plugin doesn't
+    // support the "virtual:" scheme. This resolve hook intercepts virtual
+    // module IDs before @deno/vite-plugin, letting the openElement plugin handle them.
+    { name: 'virtual-passthrough', resolveId(id) { if (id.startsWith('virtual:')) return '\0' + id; }, enforce: 'pre' },
+    deno(),
+    openElement({
+    html: { title: 'My openElement App' },
+    appShell: {
+      tagName: 'app-shell',
+      import: './app/components/app-shell.tsx',
+      props: {
+        siteName: 'My openElement App',
+      },
+    },
+    // Use pre-built UI components from @openelement/ui
+    // (npm distributes compiled JS - no decorator errors)
+    packageIslands: ['@openelement/ui'],
+    // SSR must bundle @openelement/ui (decorators need compilation)
+    ssr: {
+      noExternal: ['@openelement/ui'],
+    },
+    inject: {
+      headFragments: [
+        // Design tokens - DRY: values from @openelement/ui/open-props-tokens.ts
+        colorTokensStyle,
+      ],
+    },
+    // Blog + Navigation + Sitemap (from @openelement/content)
+    content: {
+      blog: {
+        contentDir: 'content/blog',
+        basePath: '/blog',
+      },
+      nav: {
+        routesDir: 'app/routes',
+        headerNav: [
+          { href: '/', label: 'Home' },
+          { href: '/blog', label: 'Blog' },
+        ],
+      },
+    },
+  })],
+});
+`,
+    'app/components/app-shell.tsx': `/** @jsxImportSource @openelement/core */
+import { defineLayout } from '@openelement/app';
+import { StyleSheet } from '@openelement/element';
+
+export const tagName = 'app-shell';
+
+const styles = new StyleSheet();
+styles.replaceSync(\`
+  :host { display: block; min-height: 100vh; background: var(--gray-1); }
+  header, main, footer { max-width: 860px; margin: 0 auto; padding: 1rem; }
+  header { display: flex; justify-content: space-between; align-items: center; border-bottom: 1px solid var(--gray-3); }
+  footer { color: var(--gray-7); font-size: 0.875rem; border-top: 1px solid var(--gray-3); }
+  a { color: var(--brand); text-decoration: none; font-weight: 600; }
+\`);
+
+export default defineLayout(tagName, {
+  styles,
+  render(props: { siteName?: string }) {
+    return (
+      <>
+        <header data-open-layout="app-shell">
+          <a href="/">{props.siteName ?? 'openElement'}</a>
+          <nav>
+            <a href="/freshness">Freshness</a>
+            <a href="/api/health">API health</a>
+          </nav>
+        </header>
+        <main>
+          <slot></slot>
+        </main>
+        <footer>Generated by @openelement/create.</footer>
+      </>
+    );
+  },
+});
+`,
+    'app/routes/index.tsx': `/** @jsxImportSource @openelement/core */
+import { defineElement, definePage } from '@openelement/app';
+import { StyleSheet } from '@openelement/element';
+
+export const tagName = 'home-page';
+
+const styles = new StyleSheet();
+styles.replaceSync(\`
+  :host { display: block; max-width: 800px; margin: 2rem auto; padding: 0 1rem; }
+  h1 { font-size: 2rem; margin-bottom: 0.5rem; }
+  p { color: var(--text-secondary, #666); }
+  img { width: 64px; height: 64px; }
+\`);
+
+defineElement(tagName, {
+  styles,
+  render() {
+    return (
+      <>
+        <h1>Hello from openElement!</h1>
+        <p>
+          Your openElement app is running. Edit <code>app/routes/index.tsx</code> to
+          get started.
+        </p>
+        <img src="/openelement-mark.svg" alt="openElement mark" />
+        <my-counter></my-counter>
+      </>
+    );
+  },
+});
+
+export default definePage({
+  route: { path: '/' },
+  head: {
+    title: 'My openElement App',
+    description: 'Generated openElement starter app',
+  },
+  renderIntent: {
+    mode: 'static',
+    streaming: 'auto',
+    revalidate: false,
+  },
+  render() {
+    return <home-page />;
+  },
+});
+`,
+    'app/routes/freshness.tsx': `/** @jsxImportSource @openelement/core */
+import { defineElement, definePage } from '@openelement/app';
+import { StyleSheet } from '@openelement/element';
+
+export const tagName = 'freshness-page';
+
+const styles = new StyleSheet();
+styles.replaceSync(\`
+  :host { display: block; max-width: 800px; margin: 2rem auto; padding: 0 1rem; }
+  p { color: var(--text-secondary, #666); }
+\`);
+
+defineElement(tagName, {
+  styles,
+  render() {
+    return (
+      <>
+        <h1>Freshness proof</h1>
+        <p>This page records ISR/cache intent with a 300 second revalidate window.</p>
+      </>
+    );
+  },
+});
+
+export default definePage({
+  route: { path: '/freshness' },
+  head: {
+    title: 'Freshness proof',
+    description: 'Generated openElement ISR intent route',
+  },
+  renderIntent: {
+    mode: 'static',
+    streaming: 'auto',
+    revalidate: 300,
+  },
+  render() {
+    return <freshness-page />;
+  },
+});
+`,
+    'app/routes/api/health.ts': `export default function health() {
+  return Response.json({
+    ok: true,
+    framework: 'openElement',
+    route: '/api/health',
+  });
+}
+`,
+    'app/islands/my-counter.tsx': `/** @jsxImportSource @openelement/core */
+import { defineIsland, defineIslandConfig } from '@openelement/app';
+import { signal, StyleSheet } from '@openelement/element';
+
+export const tagName = 'my-counter';
+export const openElement = defineIslandConfig({ hydrate: 'idle', ssr: true, dsd: true });
+
+const styles = new StyleSheet();
+styles.replaceSync(\`
+  :host { display: inline-flex; gap: 0.5rem; align-items: center; margin-top: 1rem; }
+  button { padding: 0.25rem 0.75rem; cursor: pointer; }
+\`);
+
+const count = signal(0);
+
+export default defineIsland(tagName, {
+  styles,
+  render() {
+    return (
+      <>
+        <button onClick={() => count.value--}>-</button>
+        <span>{count.value}</span>
+        <button onClick={() => count.value++}>+</button>
+      </>
+    );
+  },
+}, { hydrate: openElement.hydrate, dsd: openElement.dsd, ssr: openElement.ssr });
+`
+  };
+}
+async function main() {
+  const name = Deno.args[0];
+  if (!name || name === '--help' || name === '-h') {
+    console.log('Usage: deno run -A npm:@openelement/create <project-name>');
+    Deno.exit(name ? 0 : 1);
+  }
+  // H-14 fix: Validate project name format to prevent path traversal
+  if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+    log.error(`Invalid project name: "${name}". Project name must only contain letters, numbers, underscores, and hyphens.`);
+    Deno.exit(1);
+  }
+  const cwd = Deno.cwd();
+  const targetDir = resolve(cwd, name);
+  const relativeTarget = relative(cwd, targetDir);
+  if (!relativeTarget || relativeTarget === '..' || relativeTarget.startsWith(`..${sep}`) || isAbsolute(relativeTarget)) {
+    log.error(`Refusing to create project outside the current directory: ${name}`);
+    Deno.exit(1);
+  }
+  try {
+    await Deno.stat(targetDir);
+    log.error(`Directory "${name}" already exists.`);
+    Deno.exit(1);
+  } catch (e) {
+    if (!(e instanceof Deno.errors.NotFound)) {
+      log.error(`Failed to inspect target directory "${name}": ${e}`);
+      Deno.exit(1);
+    }
+  }
+  // Resolve package versions before generating templates
+  const v = await resolveVersions();
+  try {
+    await Deno.mkdir(targetDir, {
+      recursive: true
+    });
+  } catch (e) {
+    log.error(`Failed to create directory "${name}": ${e}`);
+    Deno.exit(1);
+  }
+  const TPL = buildTemplates(v);
+  for (const [path, content] of Object.entries(TPL)){
+    const fullPath = join(targetDir, path);
+    await Deno.mkdir(dirname(fullPath), {
+      recursive: true
+    });
+    await Deno.writeTextFile(fullPath, content);
+    console.info(`  created ${path}`);
+  }
+  console.info(`\nopenElement project created at ./${relativeTarget}/`);
+  console.info(`\n  cd ${relativeTarget}`);
+  console.info('  deno task dev');
+}
+main();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/create/cli.ts"],"sourcesContent":["import { Deno } from \"@deno/shim-deno\";\n/**\n * @openelement/create - Minimal project scaffold for openElement framework.\n *\n * Usage: deno run -A npm:@openelement/create my-app\n *\n * openElement Architecture: Keep It Simple, Stupid.\n * One template, zero prompts, instant start.\n */\n\nimport { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport { createLogger } from '@openelement/core/logger';\n\n// ??? Package versions ??????????????????????????????????????????\n// ADR 0016: Handle both local (workspace file://) and remote (npm registry) execution.\n//\n// - Local:  read version from workspace deno.json (single source of truth)\n// - Remote: query npm Registry API for latest version (zero hardcoding)\n\nconst NPM_SCOPE = '@openelement';\nconst log = createLogger('create');\nconst PKG_DIR_MAP: Record<string, string> = {\n  core: 'core',\n  adapterVite: 'adapter-vite',\n  app: 'app',\n  content: 'content',\n  ui: 'ui',\n  signal: 'signal',\n  element: 'element',\n};\n\nfunction loadWorkspaceVersion(pkg: string): string {\n  const metaUrl = import.meta.url;\n  const selfPath = fileURLToPath(new URL('.', metaUrl));\n  const dir = PKG_DIR_MAP[pkg] || pkg;\n  const wsPath = resolve(selfPath, '..', '..', 'packages', dir, 'deno.json');\n  try {\n    const version = JSON.parse(Deno.readTextFileSync(wsPath)).version;\n    if (!version) throw new Error(`No version found in ${wsPath}`);\n    return version;\n  } catch (e) {\n    throw new Error(\n      `Failed to read version for @openelement/${dir} from ${wsPath}. ` +\n        `Run this script from the openElement workspace or ensure deno.json is accessible.\\n` +\n        `Original error: ${e}`,\n    );\n  }\n}\n\n/** Detect whether cli.ts is being run from the openElement workspace. */\nfunction isWorkspace(): boolean {\n  try {\n    const selfPath = fileURLToPath(new URL('.', import.meta.url));\n    Deno.readTextFileSync(resolve(selfPath, '..', '..', 'packages', 'core', 'deno.json'));\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/** Fetch the latest version of an npm package from the Registry API. */\nasync function fetchNpmVersion(pkg: string): Promise<string> {\n  const resp = await fetch(`https://registry.npmjs.org/${NPM_SCOPE}/${pkg}`, {\n    headers: { Accept: 'application/json' },\n  });\n  if (!resp.ok) {\n    throw new Error(\n      `Failed to fetch version for ${NPM_SCOPE}/${pkg} from npm registry (HTTP ${resp.status})`,\n    );\n  }\n  const meta = await resp.json();\n  // npm registry response has dist-tags.latest\n  const version = meta?.['dist-tags']?.latest;\n  if (!version) {\n    throw new Error(\n      `No version found for ${NPM_SCOPE}/${pkg} in npm registry response`,\n    );\n  }\n  return version;\n}\n\n/** Resolve all package versions: local from workspace, remote from npm registry. */\nasync function resolveVersions(): Promise<Record<string, string>> {\n  const keys = Object.keys(PKG_DIR_MAP);\n  if (isWorkspace()) {\n    // Local: synchronous read from workspace\n    const v: Record<string, string> = {};\n    for (const k of keys) v[k] = loadWorkspaceVersion(k);\n    return v;\n  }\n\n  // Remote: fetch all versions from npm in parallel\n  console.info('Resolving package versions from npm...');\n  const entries = await Promise.all(\n    keys.map(async (k) => [k, await fetchNpmVersion(PKG_DIR_MAP[k])]),\n  );\n  return Object.fromEntries(entries);\n}\n\n/** Build the template map with resolved version numbers. */\nfunction buildTemplates(v: Record<string, string>): Record<string, string> {\n  return {\n    '.gitignore': `dist/\nnode_modules/\n`,\n    'public/openelement-mark.svg':\n      `<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 96 96\" role=\"img\" aria-label=\"openElement mark\">\n  <rect width=\"96\" height=\"96\" rx=\"18\" fill=\"#212529\"/>\n  <path d=\"M26 58V38l22-13 22 13v20L48 71 26 58Z\" fill=\"none\" stroke=\"#f8f9fa\" stroke-width=\"6\" stroke-linejoin=\"round\"/>\n  <path d=\"M36 48h24\" stroke=\"#7cc7ff\" stroke-width=\"6\" stroke-linecap=\"round\"/>\n</svg>\n`,\n    'deno.json': `{\n  \"imports\": {\n    \"@preact/signals-core\": \"npm:@preact/signals-core@^1.12.1\",\n    \"@deno/vite-plugin\": \"npm:@deno/vite-plugin\",\n    \"entities\": \"npm:entities@^4.5.0\",\n    \"hono\": \"npm:hono@4.12.23\",\n    \"hono/cors\": \"npm:hono@4.12.23/cors\",\n    \"hono/logger\": \"npm:hono@4.12.23/logger\",\n    \"hono/request-id\": \"npm:hono@4.12.23/request-id\",\n    \"hono/secure-headers\": \"npm:hono@4.12.23/secure-headers\",\n    \"marked\": \"npm:marked@15.0.12\",\n    \"@openelement/app\": \"npm:@openelement/app@^${v.app}\",\n    \"@openelement/app/vite\": \"npm:@openelement/app@^${v.app}/vite\",\n    \"@openelement/core\": \"npm:@openelement/core@^${v.core}\",\n    \"@openelement/core/jsx-runtime\": \"npm:@openelement/core@^${v.core}/jsx-runtime\",\n    \"@openelement/element\": \"npm:@openelement/element@^${v.element}\",\n    \"@openelement/ui\": \"npm:@openelement/ui@^${v.ui}\",\n    \"vite\": \"npm:vite@8.0.10\"\n  },\n  \"nodeModulesDir\": \"auto\",\n  \"tasks\": {\n    \"dev\": \"deno run --config deno.json -A npm:vite\",\n    \"build\": \"deno run --config deno.json -A npm:@openelement/adapter-vite@^${v.adapterVite}/cli/build\",\n    \"build:ssr\": \"deno run --config deno.json -A npm:vite build\",\n    \"build:client\": \"deno run --config deno.json -A npm:@openelement/adapter-vite@^${v.adapterVite}/cli/build-client\",\n    \"build:ssg\": \"deno run --config deno.json -A npm:@openelement/adapter-vite@^${v.adapterVite}/cli/build-ssg\",\n    \"preview\": \"deno run --config deno.json -A npm:vite preview\"\n  },\n  \"compilerOptions\": { \"lib\": [\"ES2022\", \"DOM\", \"DOM.Iterable\"], \"jsx\": \"react-jsx\", \"jsxImportSource\": \"@openelement/core\" }\n}\n`,\n    'vite.config.ts': `import { openElement } from '@openelement/app/vite';\nimport { defineConfig } from 'vite';\nimport deno from '@deno/vite-plugin';\n\n// Design tokens (from Open Props)\nconst colorTokensStyle =\n  '<style>' +\n  '--gray-0:#f8f9fa;--gray-1:#f1f3f5;--gray-3:#dee2e6;--gray-5:#adb5bd;--gray-7:#495057;--gray-9:#212529;' +\n  '--brand:#534ab7;--size-1:4px;--size-2:8px;--size-3:12px;--size-4:16px;--border-size-1:1px;--radius-2:8px;' +\n  '--font-sans:system-ui,-apple-system,sans-serif;--font-size-0:0.875rem;--font-weight-5:500;' +\n  '--shadow-1:0 1px 3px 0 rgb(0 0 0 / 0.1);' +\n  'body{margin:0;background:var(--gray-1);color:var(--gray-9);font-family:var(--font-sans);-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}</style>';\n\nexport default defineConfig({\n  plugins: [\n    // SOP-015: Virtual module passthrough — @deno/vite-plugin doesn't\n    // support the \"virtual:\" scheme. This resolve hook intercepts virtual\n    // module IDs before @deno/vite-plugin, letting the openElement plugin handle them.\n    { name: 'virtual-passthrough', resolveId(id) { if (id.startsWith('virtual:')) return '\\0' + id; }, enforce: 'pre' },\n    deno(),\n    openElement({\n    html: { title: 'My openElement App' },\n    appShell: {\n      tagName: 'app-shell',\n      import: './app/components/app-shell.tsx',\n      props: {\n        siteName: 'My openElement App',\n      },\n    },\n    // Use pre-built UI components from @openelement/ui\n    // (npm distributes compiled JS - no decorator errors)\n    packageIslands: ['@openelement/ui'],\n    // SSR must bundle @openelement/ui (decorators need compilation)\n    ssr: {\n      noExternal: ['@openelement/ui'],\n    },\n    inject: {\n      headFragments: [\n        // Design tokens - DRY: values from @openelement/ui/open-props-tokens.ts\n        colorTokensStyle,\n      ],\n    },\n    // Blog + Navigation + Sitemap (from @openelement/content)\n    content: {\n      blog: {\n        contentDir: 'content/blog',\n        basePath: '/blog',\n      },\n      nav: {\n        routesDir: 'app/routes',\n        headerNav: [\n          { href: '/', label: 'Home' },\n          { href: '/blog', label: 'Blog' },\n        ],\n      },\n    },\n  })],\n});\n`,\n    'app/components/app-shell.tsx': `/** @jsxImportSource @openelement/core */\nimport { defineLayout } from '@openelement/app';\nimport { StyleSheet } from '@openelement/element';\n\nexport const tagName = 'app-shell';\n\nconst styles = new StyleSheet();\nstyles.replaceSync(\\`\n  :host { display: block; min-height: 100vh; background: var(--gray-1); }\n  header, main, footer { max-width: 860px; margin: 0 auto; padding: 1rem; }\n  header { display: flex; justify-content: space-between; align-items: center; border-bottom: 1px solid var(--gray-3); }\n  footer { color: var(--gray-7); font-size: 0.875rem; border-top: 1px solid var(--gray-3); }\n  a { color: var(--brand); text-decoration: none; font-weight: 600; }\n\\`);\n\nexport default defineLayout(tagName, {\n  styles,\n  render(props: { siteName?: string }) {\n    return (\n      <>\n        <header data-open-layout=\"app-shell\">\n          <a href=\"/\">{props.siteName ?? 'openElement'}</a>\n          <nav>\n            <a href=\"/freshness\">Freshness</a>\n            <a href=\"/api/health\">API health</a>\n          </nav>\n        </header>\n        <main>\n          <slot></slot>\n        </main>\n        <footer>Generated by @openelement/create.</footer>\n      </>\n    );\n  },\n});\n`,\n    'app/routes/index.tsx': `/** @jsxImportSource @openelement/core */\nimport { defineElement, definePage } from '@openelement/app';\nimport { StyleSheet } from '@openelement/element';\n\nexport const tagName = 'home-page';\n\nconst styles = new StyleSheet();\nstyles.replaceSync(\\`\n  :host { display: block; max-width: 800px; margin: 2rem auto; padding: 0 1rem; }\n  h1 { font-size: 2rem; margin-bottom: 0.5rem; }\n  p { color: var(--text-secondary, #666); }\n  img { width: 64px; height: 64px; }\n\\`);\n\ndefineElement(tagName, {\n  styles,\n  render() {\n    return (\n      <>\n        <h1>Hello from openElement!</h1>\n        <p>\n          Your openElement app is running. Edit <code>app/routes/index.tsx</code> to\n          get started.\n        </p>\n        <img src=\"/openelement-mark.svg\" alt=\"openElement mark\" />\n        <my-counter></my-counter>\n      </>\n    );\n  },\n});\n\nexport default definePage({\n  route: { path: '/' },\n  head: {\n    title: 'My openElement App',\n    description: 'Generated openElement starter app',\n  },\n  renderIntent: {\n    mode: 'static',\n    streaming: 'auto',\n    revalidate: false,\n  },\n  render() {\n    return <home-page />;\n  },\n});\n`,\n    'app/routes/freshness.tsx': `/** @jsxImportSource @openelement/core */\nimport { defineElement, definePage } from '@openelement/app';\nimport { StyleSheet } from '@openelement/element';\n\nexport const tagName = 'freshness-page';\n\nconst styles = new StyleSheet();\nstyles.replaceSync(\\`\n  :host { display: block; max-width: 800px; margin: 2rem auto; padding: 0 1rem; }\n  p { color: var(--text-secondary, #666); }\n\\`);\n\ndefineElement(tagName, {\n  styles,\n  render() {\n    return (\n      <>\n        <h1>Freshness proof</h1>\n        <p>This page records ISR/cache intent with a 300 second revalidate window.</p>\n      </>\n    );\n  },\n});\n\nexport default definePage({\n  route: { path: '/freshness' },\n  head: {\n    title: 'Freshness proof',\n    description: 'Generated openElement ISR intent route',\n  },\n  renderIntent: {\n    mode: 'static',\n    streaming: 'auto',\n    revalidate: 300,\n  },\n  render() {\n    return <freshness-page />;\n  },\n});\n`,\n    'app/routes/api/health.ts': `export default function health() {\n  return Response.json({\n    ok: true,\n    framework: 'openElement',\n    route: '/api/health',\n  });\n}\n`,\n    'app/islands/my-counter.tsx': `/** @jsxImportSource @openelement/core */\nimport { defineIsland, defineIslandConfig } from '@openelement/app';\nimport { signal, StyleSheet } from '@openelement/element';\n\nexport const tagName = 'my-counter';\nexport const openElement = defineIslandConfig({ hydrate: 'idle', ssr: true, dsd: true });\n\nconst styles = new StyleSheet();\nstyles.replaceSync(\\`\n  :host { display: inline-flex; gap: 0.5rem; align-items: center; margin-top: 1rem; }\n  button { padding: 0.25rem 0.75rem; cursor: pointer; }\n\\`);\n\nconst count = signal(0);\n\nexport default defineIsland(tagName, {\n  styles,\n  render() {\n    return (\n      <>\n        <button onClick={() => count.value--}>-</button>\n        <span>{count.value}</span>\n        <button onClick={() => count.value++}>+</button>\n      </>\n    );\n  },\n}, { hydrate: openElement.hydrate, dsd: openElement.dsd, ssr: openElement.ssr });\n`,\n  };\n}\n\nasync function main() {\n  const name = Deno.args[0];\n  if (!name || name === '--help' || name === '-h') {\n    console.log('Usage: deno run -A npm:@openelement/create <project-name>');\n    Deno.exit(name ? 0 : 1);\n  }\n\n  // H-14 fix: Validate project name format to prevent path traversal\n  if (!/^[a-zA-Z0-9_-]+$/.test(name)) {\n    log.error(\n      `Invalid project name: \"${name}\". Project name must only contain letters, numbers, underscores, and hyphens.`,\n    );\n    Deno.exit(1);\n  }\n\n  const cwd = Deno.cwd();\n  const targetDir = resolve(cwd, name);\n  const relativeTarget = relative(cwd, targetDir);\n\n  if (\n    !relativeTarget ||\n    relativeTarget === '..' ||\n    relativeTarget.startsWith(`..${sep}`) ||\n    isAbsolute(relativeTarget)\n  ) {\n    log.error(\n      `Refusing to create project outside the current directory: ${name}`,\n    );\n    Deno.exit(1);\n  }\n\n  try {\n    await Deno.stat(targetDir);\n    log.error(`Directory \"${name}\" already exists.`);\n    Deno.exit(1);\n  } catch (e) {\n    if (!(e instanceof Deno.errors.NotFound)) {\n      log.error(`Failed to inspect target directory \"${name}\": ${e}`);\n      Deno.exit(1);\n    }\n  }\n\n  // Resolve package versions before generating templates\n  const v = await resolveVersions();\n\n  try {\n    await Deno.mkdir(targetDir, { recursive: true });\n  } catch (e) {\n    log.error(`Failed to create directory \"${name}\": ${e}`);\n    Deno.exit(1);\n  }\n\n  const TPL = buildTemplates(v);\n  for (const [path, content] of Object.entries(TPL)) {\n    const fullPath = join(targetDir, path);\n    await Deno.mkdir(dirname(fullPath), { recursive: true });\n    await Deno.writeTextFile(fullPath, content);\n    console.info(`  created ${path}`);\n  }\n\n  console.info(`\\nopenElement project created at ./${relativeTarget}/`);\n  console.info(`\\n  cd ${relativeTarget}`);\n  console.info('  deno task dev');\n}\n\nmain();\n"],"names":[],"mappings":"AAAA,SAAS,IAAI,QAAQ,kBAAkB;AACvC;;;;;;;CAOC,GAED,SAAS,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,QAAQ,YAAY;AAC9E,SAAS,aAAa,QAAQ,WAAW;AACzC,SAAS,YAAY,QAAQ,2BAA2B;AAExD,kEAAkE;AAClE,uFAAuF;AACvF,EAAE;AACF,2EAA2E;AAC3E,wEAAwE;AAExE,MAAM,YAAY;AAClB,MAAM,MAAM,aAAa;AACzB,MAAM,cAAsC;EAC1C,MAAM;EACN,aAAa;EACb,KAAK;EACL,SAAS;EACT,IAAI;EACJ,QAAQ;EACR,SAAS;AACX;AAEA,SAAS,qBAAqB,GAAW;EACvC,MAAM,UAAU,YAAY,GAAG;EAC/B,MAAM,WAAW,cAAc,IAAI,IAAI,KAAK;EAC5C,MAAM,MAAM,WAAW,CAAC,IAAI,IAAI;EAChC,MAAM,SAAS,QAAQ,UAAU,MAAM,MAAM,YAAY,KAAK;EAC9D,IAAI;IACF,MAAM,UAAU,KAAK,KAAK,CAAC,KAAK,gBAAgB,CAAC,SAAS,OAAO;IACjE,IAAI,CAAC,SAAS,MAAM,IAAI,MAAM,CAAC,oBAAoB,EAAE,QAAQ;IAC7D,OAAO;EACT,EAAE,OAAO,GAAG;IACV,MAAM,IAAI,MACR,CAAC,wCAAwC,EAAE,IAAI,MAAM,EAAE,OAAO,EAAE,CAAC,GAC/D,CAAC,mFAAmF,CAAC,GACrF,CAAC,gBAAgB,EAAE,GAAG;EAE5B;AACF;AAEA,uEAAuE,GACvE,SAAS;EACP,IAAI;IACF,MAAM,WAAW,cAAc,IAAI,IAAI,KAAK,YAAY,GAAG;IAC3D,KAAK,gBAAgB,CAAC,QAAQ,UAAU,MAAM,MAAM,YAAY,QAAQ;IACxE,OAAO;EACT,EAAE,OAAM;IACN,OAAO;EACT;AACF;AAEA,sEAAsE,GACtE,eAAe,gBAAgB,GAAW;EACxC,MAAM,OAAO,MAAM,MAAM,CAAC,2BAA2B,EAAE,UAAU,CAAC,EAAE,KAAK,EAAE;IACzE,SAAS;MAAE,QAAQ;IAAmB;EACxC;EACA,IAAI,CAAC,KAAK,EAAE,EAAE;IACZ,MAAM,IAAI,MACR,CAAC,4BAA4B,EAAE,UAAU,CAAC,EAAE,IAAI,yBAAyB,EAAE,KAAK,MAAM,CAAC,CAAC,CAAC;EAE7F;EACA,MAAM,OAAO,MAAM,KAAK,IAAI;EAC5B,6CAA6C;EAC7C,MAAM,UAAU,MAAM,CAAC,YAAY,EAAE;EACrC,IAAI,CAAC,SAAS;IACZ,MAAM,IAAI,MACR,CAAC,qBAAqB,EAAE,UAAU,CAAC,EAAE,IAAI,yBAAyB,CAAC;EAEvE;EACA,OAAO;AACT;AAEA,kFAAkF,GAClF,eAAe;EACb,MAAM,OAAO,OAAO,IAAI,CAAC;EACzB,IAAI,eAAe;IACjB,yCAAyC;IACzC,MAAM,IAA4B,CAAC;IACnC,KAAK,MAAM,KAAK,KAAM,CAAC,CAAC,EAAE,GAAG,qBAAqB;IAClD,OAAO;EACT;EAEA,kDAAkD;EAClD,QAAQ,IAAI,CAAC;EACb,MAAM,UAAU,MAAM,QAAQ,GAAG,CAC/B,KAAK,GAAG,CAAC,OAAO,IAAM;MAAC;MAAG,MAAM,gBAAgB,WAAW,CAAC,EAAE;KAAE;EAElE,OAAO,OAAO,WAAW,CAAC;AAC5B;AAEA,0DAA0D,GAC1D,SAAS,eAAe,CAAyB;EAC/C,OAAO;IACL,cAAc,CAAC;;AAEnB,CAAC;IACG,+BACE,CAAC;;;;;AAKP,CAAC;IACG,aAAa,CAAC;;;;;;;;;;;+CAW6B,EAAE,EAAE,GAAG,CAAC;oDACH,EAAE,EAAE,GAAG,CAAC;iDACX,EAAE,EAAE,IAAI,CAAC;6DACG,EAAE,EAAE,IAAI,CAAC;uDACf,EAAE,EAAE,OAAO,CAAC;6CACtB,EAAE,EAAE,EAAE,CAAC;;;;;;4EAMwB,EAAE,EAAE,WAAW,CAAC;;mFAET,EAAE,EAAE,WAAW,CAAC;gFACnB,EAAE,EAAE,WAAW,CAAC;;;;;AAKhG,CAAC;IACG,kBAAkB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DvB,CAAC;IACG,gCAAgC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCrC,CAAC;IACG,wBAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8C7B,CAAC;IACG,4BAA4B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCjC,CAAC;IACG,4BAA4B,CAAC;;;;;;;AAOjC,CAAC;IACG,8BAA8B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BnC,CAAC;EACC;AACF;AAEA,eAAe;EACb,MAAM,OAAO,KAAK,IAAI,CAAC,EAAE;EACzB,IAAI,CAAC,QAAQ,SAAS,YAAY,SAAS,MAAM;IAC/C,QAAQ,GAAG,CAAC;IACZ,KAAK,IAAI,CAAC,OAAO,IAAI;EACvB;EAEA,mEAAmE;EACnE,IAAI,CAAC,mBAAmB,IAAI,CAAC,OAAO;IAClC,IAAI,KAAK,CACP,CAAC,uBAAuB,EAAE,KAAK,6EAA6E,CAAC;IAE/G,KAAK,IAAI,CAAC;EACZ;EAEA,MAAM,MAAM,KAAK,GAAG;EACpB,MAAM,YAAY,QAAQ,KAAK;EAC/B,MAAM,iBAAiB,SAAS,KAAK;EAErC,IACE,CAAC,kBACD,mBAAmB,QACnB,eAAe,UAAU,CAAC,CAAC,EAAE,EAAE,KAAK,KACpC,WAAW,iBACX;IACA,IAAI,KAAK,CACP,CAAC,0DAA0D,EAAE,MAAM;IAErE,KAAK,IAAI,CAAC;EACZ;EAEA,IAAI;IACF,MAAM,KAAK,IAAI,CAAC;IAChB,IAAI,KAAK,CAAC,CAAC,WAAW,EAAE,KAAK,iBAAiB,CAAC;IAC/C,KAAK,IAAI,CAAC;EACZ,EAAE,OAAO,GAAG;IACV,IAAI,CAAC,CAAC,aAAa,KAAK,MAAM,CAAC,QAAQ,GAAG;MACxC,IAAI,KAAK,CAAC,CAAC,oCAAoC,EAAE,KAAK,GAAG,EAAE,GAAG;MAC9D,KAAK,IAAI,CAAC;IACZ;EACF;EAEA,uDAAuD;EACvD,MAAM,IAAI,MAAM;EAEhB,IAAI;IACF,MAAM,KAAK,KAAK,CAAC,WAAW;MAAE,WAAW;IAAK;EAChD,EAAE,OAAO,GAAG;IACV,IAAI,KAAK,CAAC,CAAC,4BAA4B,EAAE,KAAK,GAAG,EAAE,GAAG;IACtD,KAAK,IAAI,CAAC;EACZ;EAEA,MAAM,MAAM,eAAe;EAC3B,KAAK,MAAM,CAAC,MAAM,QAAQ,IAAI,OAAO,OAAO,CAAC,KAAM;IACjD,MAAM,WAAW,KAAK,WAAW;IACjC,MAAM,KAAK,KAAK,CAAC,QAAQ,WAAW;MAAE,WAAW;IAAK;IACtD,MAAM,KAAK,aAAa,CAAC,UAAU;IACnC,QAAQ,IAAI,CAAC,CAAC,UAAU,EAAE,MAAM;EAClC;EAEA,QAAQ,IAAI,CAAC,CAAC,mCAAmC,EAAE,eAAe,CAAC,CAAC;EACpE,QAAQ,IAAI,CAAC,CAAC,OAAO,EAAE,gBAAgB;EACvC,QAAQ,IAAI,CAAC;AACf;AAEA"}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@openelement/create",
+  "version": "0.41.0-alpha.1",
+  "type": "module",
+  "main": "./cli.js",
+  "types": "./cli.d.ts",
+  "exports": {
+    ".": {
+      "types": "./cli.d.ts",
+      "import": "./cli.js",
+      "default": "./cli.js"
+    }
+  },
+  "dependencies": {
+    "@deno/shim-deno": "~0.19.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/open-element/openelement.git"
+  },
+  "keywords": [
+    "openelement",
+    "web-components",
+    "ssg",
+    "framework",
+    "deno"
+  ],
+  "bin": {
+    "openelement-create": "./cli.js",
+    "create-openelement": "./cli.js"
+  }
+}