@openelement/core 0.41.0-alpha.1

package/src/logger.js

@@ -0,0 +1,24 @@
+/**
+ * @openelement/core - Tagged console logger.
+ *
+ * Lightweight scoped logger. Returns plain functions so it is tree-shakable
+ * and has zero class overhead.
+ *
+ * @module @openelement/core/logger
+ */ export function createLogger(tag) {
+  return {
+    debug: (msg, ...args)=>console.debug(`[${tag}] ${msg}`, ...args),
+    info: (msg, ...args)=>console.info(`[${tag}] ${msg}`, ...args),
+    warn: (msg, ...args)=>console.warn(`[${tag}] ${msg}`, ...args),
+    error: (msg, ...args)=>console.error(`[${tag}] ${msg}`, ...args)
+  };
+}
+// ponytail: warn-once via Set, two callers, shared helper if >3 callers
+const _warned = new Set();
+export function warnOnce(key, logger, msg) {
+  if (!_warned.has(key)) {
+    _warned.add(key);
+    logger.warn(msg);
+  }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/src/prop.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @openelement/core — Reactive property runtime.
+ *
+ * ADR-0057: static props + Signal model.
+ *
+ * v0.29.5: WeakMap replaces Symbol.for() for type-safe signal storage.
+ */ interface _El extends HTMLElement {
+}
+import type { PropDecl, PropDeclFull, PropDeclShorthand, PropsFrom, PropType } from '@openelement/protocol/prop';
+export type { PropDecl, PropDeclFull, PropDeclShorthand, PropsFrom, PropType };
+export declare function initializeStaticProps(instance: _El): void;
+export declare function disposeStaticProps(instance: _El): void;
+export declare function handleStaticPropAttributeChange(instance: _El, name: string, _oldValue: string | null, newValue: string | null): void;
+export declare function syncStaticPropsFromAttributes(instance: _El): void;
+export declare function unwrap<T>(sig: {
+  value: T;
+} | T): T;
+import type { NormalizedPropDecl } from '@openelement/protocol/prop';
+export type { NormalizedPropDecl };
+export declare function normalizePropDecl(decl: unknown): NormalizedPropDecl;
+export declare function registerStaticObservedAttributes(ctor: {
+  props?: Record<string, unknown>;
+  observedAttributes?: string[];
+}, propsDef: Record<string, unknown>): void;

package/src/prop.js

@@ -0,0 +1,160 @@
+/**
+ * @openelement/core — Reactive property runtime.
+ *
+ * ADR-0057: static props + Signal model.
+ *
+ * v0.29.5: WeakMap replaces Symbol.for() for type-safe signal storage.
+ */ // Minimal element interface for core WeakMap identity
+// ─── WeakMap storage (v0.29.5: replaces Symbol.for()) ───────────
+const _staticPropSignals = new WeakMap();
+const _staticPropUnsubs = new WeakMap();
+// ─── Static props runtime ───────────────────────────────────────
+export function initializeStaticProps(instance) {
+  const ctor = instance.constructor;
+  const propsDef = ctor.props;
+  if (!propsDef || typeof propsDef !== 'object') return;
+  const sigMap = new Map();
+  _staticPropSignals.set(instance, sigMap);
+  const unsubs = [];
+  _staticPropUnsubs.set(instance, unsubs);
+  for (const [name, decl] of Object.entries(propsDef)){
+    const { default: defVal, reflect } = normalizePropDecl(decl);
+    const sig = createPropSignal(defVal);
+    sigMap.set(name, sig);
+    Object.defineProperty(instance, name, {
+      get () {
+        return sig;
+      },
+      set (v1) {
+        sig.value = v1;
+      },
+      enumerable: true,
+      configurable: true
+    });
+    if (reflect) {
+      const unsub = sig.subscribe(()=>{
+        const { type } = normalizePropDecl(decl);
+        if (type === Boolean) {
+          if (sig.value) instance.setAttribute(name, '');
+          else instance.removeAttribute(name);
+        } else {
+          instance.setAttribute(name, String(sig.value));
+        }
+      });
+      unsubs.push(unsub);
+    }
+  }
+  registerStaticObservedAttributes(ctor, propsDef);
+}
+export function disposeStaticProps(instance) {
+  const unsubs = _staticPropUnsubs.get(instance);
+  if (unsubs) {
+    for (const fn of unsubs.splice(0))fn();
+  }
+}
+export function handleStaticPropAttributeChange(instance, name, _oldValue, newValue) {
+  const sigMap = _staticPropSignals.get(instance);
+  if (!sigMap) return;
+  const ctor = instance.constructor;
+  const propsDef = ctor.props;
+  if (!propsDef) return;
+  for (const [propName, decl] of Object.entries(propsDef)){
+    if (propName.toLowerCase() !== name.toLowerCase()) continue;
+    const sig = sigMap.get(propName);
+    if (!sig) continue;
+    const { type } = normalizePropDecl(decl);
+    if (newValue === null) {
+      sig.value = type === Boolean ? false : type === Number ? 0 : '';
+    } else if (type === Boolean) {
+      sig.value = true;
+    } else if (type === Number) {
+      const n = Number(newValue);
+      sig.value = Number.isNaN(n) ? 0 : n;
+    } else {
+      sig.value = newValue;
+    }
+    return;
+  }
+}
+export function syncStaticPropsFromAttributes(instance) {
+  const ctor = instance.constructor;
+  const propsDef = ctor.props;
+  if (!propsDef) return;
+  const sigMap = _staticPropSignals.get(instance);
+  if (!sigMap) return;
+  const el = instance;
+  for (const [name, decl] of Object.entries(propsDef)){
+    const sig = sigMap.get(name);
+    if (!sig) continue;
+    if (el.hasAttribute(name)) {
+      const { type } = normalizePropDecl(decl);
+      const raw = el.getAttribute(name);
+      if (raw === null) continue;
+      if (type === Boolean) {
+        sig.value = true;
+      } else if (type === Number) {
+        const n = Number(raw);
+        sig.value = Number.isNaN(n) ? 0 : n;
+      } else {
+        sig.value = raw;
+      }
+    }
+  }
+}
+export function unwrap(sig) {
+  if (sig !== null && typeof sig === 'object' && 'value' in sig && 'subscribe' in sig) {
+    return sig.value;
+  }
+  return sig;
+}
+export function normalizePropDecl(decl) {
+  if (typeof decl === 'function') {
+    return {
+      type: decl,
+      default: decl === Boolean ? false : decl === Number ? 0 : '',
+      reflect: false
+    };
+  }
+  if (decl && typeof decl === 'object') {
+    const d = decl;
+    return {
+      type: d.type ?? String,
+      default: d.default ?? (d.type === Boolean ? false : d.type === Number ? 0 : ''),
+      reflect: d.reflect === true
+    };
+  }
+  return {
+    type: String,
+    default: '',
+    reflect: false
+  };
+}
+export function registerStaticObservedAttributes(ctor, propsDef) {
+  if (!ctor.observedAttributes) {
+    ctor.observedAttributes = [];
+  }
+  for (const name of Object.keys(propsDef)){
+    if (!ctor.observedAttributes.includes(name.toLowerCase())) {
+      ctor.observedAttributes.push(name.toLowerCase());
+    }
+  }
+}
+function createPropSignal(initial) {
+  let _value = initial;
+  const _subs = new Set();
+  return {
+    get value () {
+      return _value;
+    },
+    set value (v){
+      _value = v;
+      for (const fn of _subs)fn(v);
+    },
+    subscribe (fn) {
+      _subs.add(fn);
+      fn(_value);
+      return ()=>_subs.delete(fn);
+    }
+  };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/core/src/prop.ts"],"sourcesContent":["/**\n * @openelement/core — Reactive property runtime.\n *\n * ADR-0057: static props + Signal model.\n *\n * v0.29.5: WeakMap replaces Symbol.for() for type-safe signal storage.\n */\n\n// Minimal element interface for core WeakMap identity\ninterface _El extends HTMLElement {}\n\nimport type {\n  PropDecl,\n  PropDeclFull,\n  PropDeclShorthand,\n  PropsFrom,\n  PropType,\n} from '@openelement/protocol/prop';\nexport type { PropDecl, PropDeclFull, PropDeclShorthand, PropsFrom, PropType };\n\n// ─── Internal types ─────────────────────────────────────────────\n\ntype PropSignal = { value: unknown; subscribe(fn: (v: unknown) => void): () => void };\n\n// ─── WeakMap storage (v0.29.5: replaces Symbol.for()) ───────────\n\nconst _staticPropSignals = new WeakMap<_El, Map<string, PropSignal>>();\nconst _staticPropUnsubs = new WeakMap<_El, Array<() => void>>();\n\n// ─── Static props runtime ───────────────────────────────────────\n\nexport function initializeStaticProps(instance: _El): void {\n  const ctor = instance.constructor as { props?: Record<string, unknown> };\n  const propsDef = ctor.props as Record<string, unknown> | undefined;\n  if (!propsDef || typeof propsDef !== 'object') return;\n\n  const sigMap = new Map<string, PropSignal>();\n  _staticPropSignals.set(instance, sigMap);\n\n  const unsubs: Array<() => void> = [];\n  _staticPropUnsubs.set(instance, unsubs);\n\n  for (const [name, decl] of Object.entries(propsDef)) {\n    const { default: defVal, reflect } = normalizePropDecl(decl);\n    const sig = createPropSignal(defVal);\n\n    sigMap.set(name, sig);\n\n    Object.defineProperty(instance, name, {\n      get() {\n        return sig;\n      },\n      set(v: unknown) {\n        sig.value = v;\n      },\n      enumerable: true,\n      configurable: true,\n    });\n\n    if (reflect) {\n      const unsub = sig.subscribe(() => {\n        const { type } = normalizePropDecl(decl);\n        if (type === Boolean) {\n          if (sig.value) instance.setAttribute(name, '');\n          else instance.removeAttribute(name);\n        } else {\n          instance.setAttribute(name, String(sig.value));\n        }\n      });\n      unsubs.push(unsub);\n    }\n  }\n\n  registerStaticObservedAttributes(ctor, propsDef);\n}\n\nexport function disposeStaticProps(instance: _El): void {\n  const unsubs = _staticPropUnsubs.get(instance);\n  if (unsubs) {\n    for (const fn of unsubs.splice(0)) fn();\n  }\n}\n\nexport function handleStaticPropAttributeChange(\n  instance: _El,\n  name: string,\n  _oldValue: string | null,\n  newValue: string | null,\n): void {\n  const sigMap = _staticPropSignals.get(instance);\n  if (!sigMap) return;\n\n  const ctor = instance.constructor as { props?: Record<string, unknown> };\n  const propsDef = ctor.props as Record<string, unknown> | undefined;\n  if (!propsDef) return;\n\n  for (const [propName, decl] of Object.entries(propsDef)) {\n    if (propName.toLowerCase() !== name.toLowerCase()) continue;\n    const sig = sigMap.get(propName);\n    if (!sig) continue;\n    const { type } = normalizePropDecl(decl);\n    if (newValue === null) {\n      sig.value = type === Boolean ? false : type === Number ? 0 : '';\n    } else if (type === Boolean) {\n      sig.value = true;\n    } else if (type === Number) {\n      const n = Number(newValue);\n      sig.value = Number.isNaN(n) ? 0 : n;\n    } else {\n      sig.value = newValue;\n    }\n    return;\n  }\n}\n\nexport function syncStaticPropsFromAttributes(instance: _El): void {\n  const ctor = instance.constructor as { props?: Record<string, unknown> };\n  const propsDef = ctor.props as Record<string, unknown> | undefined;\n  if (!propsDef) return;\n\n  const sigMap = _staticPropSignals.get(instance);\n  if (!sigMap) return;\n\n  const el = instance as unknown as {\n    getAttribute(n: string): string | null;\n    hasAttribute(n: string): boolean;\n  };\n\n  for (const [name, decl] of Object.entries(propsDef)) {\n    const sig = sigMap.get(name);\n    if (!sig) continue;\n    if (el.hasAttribute(name)) {\n      const { type } = normalizePropDecl(decl);\n      const raw = el.getAttribute(name);\n      if (raw === null) continue;\n      if (type === Boolean) {\n        sig.value = true;\n      } else if (type === Number) {\n        const n = Number(raw);\n        sig.value = Number.isNaN(n) ? 0 : n;\n      } else {\n        sig.value = raw;\n      }\n    }\n  }\n}\n\nexport function unwrap<T>(sig: { value: T } | T): T {\n  if (\n    sig !== null && typeof sig === 'object' && 'value' in (sig as object) &&\n    'subscribe' in (sig as object)\n  ) {\n    return (sig as { value: T }).value;\n  }\n  return sig as T;\n}\n\n// ─── Shared utilities ───────────────────────────────────────────\n\nimport type { NormalizedPropDecl } from '@openelement/protocol/prop';\nexport type { NormalizedPropDecl };\n\nexport function normalizePropDecl(decl: unknown): NormalizedPropDecl {\n  if (typeof decl === 'function') {\n    return {\n      type: decl as NormalizedPropDecl['type'],\n      default: decl === Boolean ? false : decl === Number ? 0 : '',\n      reflect: false,\n    };\n  }\n  if (decl && typeof decl === 'object') {\n    const d = decl as { type?: unknown; default?: unknown; reflect?: unknown };\n    return {\n      type: (d.type ?? String) as NormalizedPropDecl['type'],\n      default: d.default ?? (d.type === Boolean ? false : d.type === Number ? 0 : ''),\n      reflect: d.reflect === true,\n    };\n  }\n  return { type: String, default: '', reflect: false };\n}\n\nexport function registerStaticObservedAttributes(\n  ctor: { props?: Record<string, unknown>; observedAttributes?: string[] },\n  propsDef: Record<string, unknown>,\n): void {\n  if (!ctor.observedAttributes) {\n    ctor.observedAttributes = [];\n  }\n  for (const name of Object.keys(propsDef)) {\n    if (!ctor.observedAttributes.includes(name.toLowerCase())) {\n      ctor.observedAttributes.push(name.toLowerCase());\n    }\n  }\n}\n\nfunction createPropSignal(initial: unknown): PropSignal {\n  let _value = initial;\n  const _subs = new Set<(v: unknown) => void>();\n\n  return {\n    get value(): unknown {\n      return _value;\n    },\n    set value(v: unknown) {\n      _value = v;\n      for (const fn of _subs) fn(v);\n    },\n    subscribe(fn: (v: unknown) => void): () => void {\n      _subs.add(fn);\n      fn(_value);\n      return () => _subs.delete(fn);\n    },\n  };\n}\n"],"names":[],"mappings":"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"}

package/src/registry.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @openelement/core - Local WC Package Registry
+ *
+ * Provides registration, lookup, validation, and indexing for
+ * OpenElementPackageManifest instances. This is the foundation for
+ * the v0.16 WC Package Protocol.
+ *
+ * The registry is local (in-process) only. Public hub support
+ * is a future concern (v0.18+).
+ */ import type { OpenElementDeclaration, OpenElementPackageManifest } from '@openelement/protocol/manifest';
+import type { RegistryIndex, ValidationResult } from '@openelement/protocol/framework';
+/** Register a package manifest with the local registry. */ export declare function register(manifest: OpenElementPackageManifest): void;
+/** Look up a declaration by its custom element tag name. */ export declare function getByTagName(tagName: string): OpenElementDeclaration | undefined;
+/** Get all registered package manifests. */ export declare function getAll(): readonly OpenElementPackageManifest[];
+/** Validate a package manifest against the openElement protocol rules. */ export declare function validate(manifest: OpenElementPackageManifest): ValidationResult;
+/** Generate an aggregated index of all registered manifests. */ export declare function generateIndex(): RegistryIndex;
+/** Clear all registered manifests (useful for testing). */ export declare function clear(): void;

package/src/registry.js

@@ -0,0 +1,219 @@
+/**
+ * @openelement/core - Local WC Package Registry
+ *
+ * Provides registration, lookup, validation, and indexing for
+ * OpenElementPackageManifest instances. This is the foundation for
+ * the v0.16 WC Package Protocol.
+ *
+ * The registry is local (in-process) only. Public hub support
+ * is a future concern (v0.18+).
+ */ const _packages = [];
+/** Register a package manifest with the local registry. */ export function register(manifest) {
+  const existing = _packages.find((p)=>p.packageName === manifest.packageName);
+  if (existing) {
+    const idx = _packages.indexOf(existing);
+    _packages[idx] = manifest;
+  } else {
+    _packages.push(manifest);
+  }
+}
+/** Look up a declaration by its custom element tag name. */ export function getByTagName(tagName) {
+  for (const pkg of _packages){
+    const decl = pkg.declarations.find((d)=>d.tagName === tagName);
+    if (decl) return decl;
+  }
+  return undefined;
+}
+/** Get all registered package manifests. */ export function getAll() {
+  return _packages;
+}
+/** Validate a package manifest against the openElement protocol rules. */ export function validate(manifest) {
+  const errors = [];
+  const warnings = [];
+  // 1. Required fields
+  if (!manifest.packageName) {
+    errors.push({
+      code: 'MISSING_PACKAGE_NAME',
+      message: 'packageName is required',
+      path: 'packageName'
+    });
+  }
+  if (!manifest.version) {
+    errors.push({
+      code: 'MISSING_VERSION',
+      message: 'version is required',
+      path: 'version'
+    });
+  }
+  if (!manifest.schemaVersion) {
+    errors.push({
+      code: 'MISSING_SCHEMA_VERSION',
+      message: 'schemaVersion is required',
+      path: 'schemaVersion'
+    });
+  }
+  if (!manifest.declarations || manifest.declarations.length === 0) {
+    errors.push({
+      code: 'MISSING_DECLARATIONS',
+      message: 'At least one declaration is required',
+      path: 'declarations'
+    });
+  }
+  // 2. Validate each declaration
+  const tagNames = new Set();
+  for(let i = 0; i < (manifest.declarations ?? []).length; i++){
+    const decl = manifest.declarations[i];
+    const path = `declarations[${i}]`;
+    if (!decl.tagName) {
+      errors.push({
+        code: 'MISSING_TAG_NAME',
+        message: 'tagName is required for each declaration',
+        path: `${path}.tagName`
+      });
+      continue;
+    }
+    // 3. Invalid custom element name
+    if (!isValidCustomElementName(decl.tagName)) {
+      errors.push({
+        code: 'INVALID_TAG_NAME',
+        message: `"${decl.tagName}" is not a valid custom element name (must contain a hyphen and start with a letter)`,
+        path: `${path}.tagName`
+      });
+    }
+    // 5. Duplicate tag names within a package
+    if (tagNames.has(decl.tagName)) {
+      errors.push({
+        code: 'DUPLICATE_TAG_NAME',
+        message: `Duplicate tagName "${decl.tagName}" within package`,
+        path: `${path}.tagName`
+      });
+    }
+    tagNames.add(decl.tagName);
+    // 4. Unsafe module paths
+    if (decl.openElement?.module) {
+      if (isUnsafeModulePath(decl.openElement.module)) {
+        errors.push({
+          code: 'UNSAFE_MODULE_PATH',
+          message: `Module path "${decl.openElement.module}" contains unsafe patterns`,
+          path: `${path}.openElement.module`
+        });
+      }
+    }
+    // 4. Invalid layer
+    if (decl.openElement?.layer && ![
+      'dsd-static',
+      'dsd-interactive',
+      'pure-island'
+    ].includes(decl.openElement.layer)) {
+      errors.push({
+        code: 'INVALID_LAYER',
+        message: `Invalid layer "${decl.openElement.layer}" (must be dsd-static, dsd-interactive, or pure-island)`,
+        path: `${path}.openElement.layer`
+      });
+    }
+    // 4. Invalid hydrate strategy
+    if (decl.openElement?.hydrate && ![
+      'load',
+      'idle',
+      'visible',
+      'only'
+    ].includes(decl.openElement.hydrate)) {
+      errors.push({
+        code: 'INVALID_HYDRATE_STRATEGY',
+        message: `Invalid hydrate strategy "${decl.openElement.hydrate}"`,
+        path: `${path}.openElement.hydrate`
+      });
+    }
+  }
+  // 6. Unresolved export declaration references
+  if (manifest.modules) {
+    for(let mi = 0; mi < manifest.modules.length; mi++){
+      const mod = manifest.modules[mi];
+      if (mod.declarations) {
+        for (const declRef of mod.declarations){
+          const found = manifest.declarations.some((d)=>d.tagName === declRef || d.className === declRef);
+          if (!found) {
+            warnings.push({
+              code: 'UNRESOLVED_DECLARATION_REF',
+              message: `Module references declaration "${declRef}" which is not in the declarations array`,
+              path: `modules[${mi}].declarations`
+            });
+          }
+        }
+      }
+    }
+  }
+  // 7. Registry-level duplicate tag names (across packages)
+  for (const decl of manifest.declarations ?? []){
+    if (!decl.tagName) continue;
+    for (const existingPkg of _packages){
+      if (existingPkg.packageName === manifest.packageName) continue;
+      const conflict = existingPkg.declarations.find((d)=>d.tagName === decl.tagName);
+      if (conflict) {
+        warnings.push({
+          code: 'REGISTRY_TAG_CONFLICT',
+          message: `tagName "${decl.tagName}" already registered by ${existingPkg.packageName}`,
+          path: `declarations[${manifest.declarations.indexOf(decl)}].tagName`
+        });
+      }
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+/** Generate an aggregated index of all registered manifests. */ export function generateIndex() {
+  const entries = [];
+  for (const pkg of _packages){
+    for (const decl of pkg.declarations){
+      entries.push({
+        tagName: decl.tagName,
+        packageName: pkg.packageName,
+        version: pkg.version,
+        module: decl.openElement?.module,
+        ssr: decl.openElement?.ssr,
+        dsd: decl.openElement?.dsd,
+        hydrate: decl.openElement?.hydrate
+      });
+    }
+  }
+  entries.sort((a, b)=>a.tagName.localeCompare(b.tagName));
+  return {
+    totalPackages: _packages.length,
+    totalDeclarations: entries.length,
+    entries
+  };
+}
+/** Clear all registered manifests (useful for testing). */ export function clear() {
+  _packages.length = 0;
+}
+/** Check if a tag name is a valid custom element name per HTML spec. */ function isValidCustomElementName(name) {
+  // Must contain a hyphen, start with a lowercase letter, and only
+  // contain allowed characters. Must not be a reserved name.
+  if (!name) return false;
+  const reserved = new Set([
+    'annotation-xml',
+    'color-profile',
+    'font-face',
+    'font-face-src',
+    'font-face-uri',
+    'font-face-format',
+    'font-face-name',
+    'missing-glyph'
+  ]);
+  if (reserved.has(name)) return false;
+  // Basic check: starts with letter, contains hyphen, only [a-z0-9-]
+  return /^[a-z][a-z0-9]*-[a-z0-9-]*$/.test(name);
+}
+/** Check if a module path contains unsafe patterns. */ function isUnsafeModulePath(path) {
+  // Reject paths with directory traversal, absolute paths, or protocol handlers
+  if (path.startsWith('/') || path.startsWith('\\')) return true;
+  if (path.includes('..')) return true;
+  if (/^[a-z]+:\/\//i.test(path) && !path.startsWith('jsr:') && !path.startsWith('npm:')) {
+    return true;
+  }
+  return false;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/core/src/registry.ts"],"sourcesContent":["/**\n * @openelement/core - Local WC Package Registry\n *\n * Provides registration, lookup, validation, and indexing for\n * OpenElementPackageManifest instances. This is the foundation for\n * the v0.16 WC Package Protocol.\n *\n * The registry is local (in-process) only. Public hub support\n * is a future concern (v0.18+).\n */\n\nimport type {\n  OpenElementDeclaration,\n  OpenElementPackageManifest,\n} from '@openelement/protocol/manifest';\nimport type {\n  RegistryIndex,\n  RegistryIndexEntry,\n  ValidationError,\n  ValidationResult,\n  ValidationWarning,\n} from '@openelement/protocol/framework';\n\nconst _packages: OpenElementPackageManifest[] = [];\n\n/** Register a package manifest with the local registry. */\nexport function register(manifest: OpenElementPackageManifest): void {\n  const existing = _packages.find((p) => p.packageName === manifest.packageName);\n  if (existing) {\n    const idx = _packages.indexOf(existing);\n    _packages[idx] = manifest;\n  } else {\n    _packages.push(manifest);\n  }\n}\n\n/** Look up a declaration by its custom element tag name. */\nexport function getByTagName(tagName: string): OpenElementDeclaration | undefined {\n  for (const pkg of _packages) {\n    const decl = pkg.declarations.find((d) => d.tagName === tagName);\n    if (decl) return decl;\n  }\n  return undefined;\n}\n\n/** Get all registered package manifests. */\nexport function getAll(): readonly OpenElementPackageManifest[] {\n  return _packages;\n}\n\n/** Validate a package manifest against the openElement protocol rules. */\nexport function validate(manifest: OpenElementPackageManifest): ValidationResult {\n  const errors: ValidationError[] = [];\n  const warnings: ValidationWarning[] = [];\n\n  // 1. Required fields\n  if (!manifest.packageName) {\n    errors.push({\n      code: 'MISSING_PACKAGE_NAME',\n      message: 'packageName is required',\n      path: 'packageName',\n    });\n  }\n  if (!manifest.version) {\n    errors.push({\n      code: 'MISSING_VERSION',\n      message: 'version is required',\n      path: 'version',\n    });\n  }\n  if (!manifest.schemaVersion) {\n    errors.push({\n      code: 'MISSING_SCHEMA_VERSION',\n      message: 'schemaVersion is required',\n      path: 'schemaVersion',\n    });\n  }\n  if (!manifest.declarations || manifest.declarations.length === 0) {\n    errors.push({\n      code: 'MISSING_DECLARATIONS',\n      message: 'At least one declaration is required',\n      path: 'declarations',\n    });\n  }\n\n  // 2. Validate each declaration\n  const tagNames = new Set<string>();\n  for (let i = 0; i < (manifest.declarations ?? []).length; i++) {\n    const decl = manifest.declarations[i];\n    const path = `declarations[${i}]`;\n\n    if (!decl.tagName) {\n      errors.push({\n        code: 'MISSING_TAG_NAME',\n        message: 'tagName is required for each declaration',\n        path: `${path}.tagName`,\n      });\n      continue;\n    }\n\n    // 3. Invalid custom element name\n    if (!isValidCustomElementName(decl.tagName)) {\n      errors.push({\n        code: 'INVALID_TAG_NAME',\n        message:\n          `\"${decl.tagName}\" is not a valid custom element name (must contain a hyphen and start with a letter)`,\n        path: `${path}.tagName`,\n      });\n    }\n\n    // 5. Duplicate tag names within a package\n    if (tagNames.has(decl.tagName)) {\n      errors.push({\n        code: 'DUPLICATE_TAG_NAME',\n        message: `Duplicate tagName \"${decl.tagName}\" within package`,\n        path: `${path}.tagName`,\n      });\n    }\n    tagNames.add(decl.tagName);\n\n    // 4. Unsafe module paths\n    if (decl.openElement?.module) {\n      if (isUnsafeModulePath(decl.openElement.module)) {\n        errors.push({\n          code: 'UNSAFE_MODULE_PATH',\n          message: `Module path \"${decl.openElement.module}\" contains unsafe patterns`,\n          path: `${path}.openElement.module`,\n        });\n      }\n    }\n\n    // 4. Invalid layer\n    if (\n      decl.openElement?.layer &&\n      !['dsd-static', 'dsd-interactive', 'pure-island'].includes(decl.openElement.layer)\n    ) {\n      errors.push({\n        code: 'INVALID_LAYER',\n        message:\n          `Invalid layer \"${decl.openElement.layer}\" (must be dsd-static, dsd-interactive, or pure-island)`,\n        path: `${path}.openElement.layer`,\n      });\n    }\n\n    // 4. Invalid hydrate strategy\n    if (\n      decl.openElement?.hydrate &&\n      !['load', 'idle', 'visible', 'only'].includes(decl.openElement.hydrate)\n    ) {\n      errors.push({\n        code: 'INVALID_HYDRATE_STRATEGY',\n        message: `Invalid hydrate strategy \"${decl.openElement.hydrate}\"`,\n        path: `${path}.openElement.hydrate`,\n      });\n    }\n  }\n\n  // 6. Unresolved export declaration references\n  if (manifest.modules) {\n    for (let mi = 0; mi < manifest.modules.length; mi++) {\n      const mod = manifest.modules[mi];\n      if (mod.declarations) {\n        for (const declRef of mod.declarations) {\n          const found = manifest.declarations.some(\n            (d) => d.tagName === declRef || d.className === declRef,\n          );\n          if (!found) {\n            warnings.push({\n              code: 'UNRESOLVED_DECLARATION_REF',\n              message:\n                `Module references declaration \"${declRef}\" which is not in the declarations array`,\n              path: `modules[${mi}].declarations`,\n            });\n          }\n        }\n      }\n    }\n  }\n\n  // 7. Registry-level duplicate tag names (across packages)\n  for (const decl of manifest.declarations ?? []) {\n    if (!decl.tagName) continue;\n    for (const existingPkg of _packages) {\n      if (existingPkg.packageName === manifest.packageName) continue;\n      const conflict = existingPkg.declarations.find((d) => d.tagName === decl.tagName);\n      if (conflict) {\n        warnings.push({\n          code: 'REGISTRY_TAG_CONFLICT',\n          message: `tagName \"${decl.tagName}\" already registered by ${existingPkg.packageName}`,\n          path: `declarations[${manifest.declarations.indexOf(decl)}].tagName`,\n        });\n      }\n    }\n  }\n\n  return {\n    valid: errors.length === 0,\n    errors,\n    warnings,\n  };\n}\n\n/** Generate an aggregated index of all registered manifests. */\nexport function generateIndex(): RegistryIndex {\n  const entries: RegistryIndexEntry[] = [];\n\n  for (const pkg of _packages) {\n    for (const decl of pkg.declarations) {\n      entries.push({\n        tagName: decl.tagName,\n        packageName: pkg.packageName,\n        version: pkg.version,\n        module: decl.openElement?.module,\n        ssr: decl.openElement?.ssr,\n        dsd: decl.openElement?.dsd,\n        hydrate: decl.openElement?.hydrate,\n      });\n    }\n  }\n\n  entries.sort((a, b) => a.tagName.localeCompare(b.tagName));\n\n  return {\n    totalPackages: _packages.length,\n    totalDeclarations: entries.length,\n    entries,\n  };\n}\n\n/** Clear all registered manifests (useful for testing). */\nexport function clear(): void {\n  _packages.length = 0;\n}\n\n/** Check if a tag name is a valid custom element name per HTML spec. */\nfunction isValidCustomElementName(name: string): boolean {\n  // Must contain a hyphen, start with a lowercase letter, and only\n  // contain allowed characters. Must not be a reserved name.\n  if (!name) return false;\n  const reserved = new Set([\n    'annotation-xml',\n    'color-profile',\n    'font-face',\n    'font-face-src',\n    'font-face-uri',\n    'font-face-format',\n    'font-face-name',\n    'missing-glyph',\n  ]);\n  if (reserved.has(name)) return false;\n  // Basic check: starts with letter, contains hyphen, only [a-z0-9-]\n  return /^[a-z][a-z0-9]*-[a-z0-9-]*$/.test(name);\n}\n\n/** Check if a module path contains unsafe patterns. */\nfunction isUnsafeModulePath(path: string): boolean {\n  // Reject paths with directory traversal, absolute paths, or protocol handlers\n  if (path.startsWith('/') || path.startsWith('\\\\')) return true;\n  if (path.includes('..')) return true;\n  if (/^[a-z]+:\\/\\//i.test(path) && !path.startsWith('jsr:') && !path.startsWith('npm:')) {\n    return true;\n  }\n  return false;\n}\n"],"names":[],"mappings":"AAAA;;;;;;;;;CASC,GAcD,MAAM,YAA0C,EAAE;AAElD,yDAAyD,GACzD,OAAO,SAAS,SAAS,QAAoC;EAC3D,MAAM,WAAW,UAAU,IAAI,CAAC,CAAC,IAAM,EAAE,WAAW,KAAK,SAAS,WAAW;EAC7E,IAAI,UAAU;IACZ,MAAM,MAAM,UAAU,OAAO,CAAC;IAC9B,SAAS,CAAC,IAAI,GAAG;EACnB,OAAO;IACL,UAAU,IAAI,CAAC;EACjB;AACF;AAEA,0DAA0D,GAC1D,OAAO,SAAS,aAAa,OAAe;EAC1C,KAAK,MAAM,OAAO,UAAW;IAC3B,MAAM,OAAO,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC,IAAM,EAAE,OAAO,KAAK;IACxD,IAAI,MAAM,OAAO;EACnB;EACA,OAAO;AACT;AAEA,0CAA0C,GAC1C,OAAO,SAAS;EACd,OAAO;AACT;AAEA,wEAAwE,GACxE,OAAO,SAAS,SAAS,QAAoC;EAC3D,MAAM,SAA4B,EAAE;EACpC,MAAM,WAAgC,EAAE;EAExC,qBAAqB;EACrB,IAAI,CAAC,SAAS,WAAW,EAAE;IACzB,OAAO,IAAI,CAAC;MACV,MAAM;MACN,SAAS;MACT,MAAM;IACR;EACF;EACA,IAAI,CAAC,SAAS,OAAO,EAAE;IACrB,OAAO,IAAI,CAAC;MACV,MAAM;MACN,SAAS;MACT,MAAM;IACR;EACF;EACA,IAAI,CAAC,SAAS,aAAa,EAAE;IAC3B,OAAO,IAAI,CAAC;MACV,MAAM;MACN,SAAS;MACT,MAAM;IACR;EACF;EACA,IAAI,CAAC,SAAS,YAAY,IAAI,SAAS,YAAY,CAAC,MAAM,KAAK,GAAG;IAChE,OAAO,IAAI,CAAC;MACV,MAAM;MACN,SAAS;MACT,MAAM;IACR;EACF;EAEA,+BAA+B;EAC/B,MAAM,WAAW,IAAI;EACrB,IAAK,IAAI,IAAI,GAAG,IAAI,CAAC,SAAS,YAAY,IAAI,EAAE,EAAE,MAAM,EAAE,IAAK;IAC7D,MAAM,OAAO,SAAS,YAAY,CAAC,EAAE;IACrC,MAAM,OAAO,CAAC,aAAa,EAAE,EAAE,CAAC,CAAC;IAEjC,IAAI,CAAC,KAAK,OAAO,EAAE;MACjB,OAAO,IAAI,CAAC;QACV,MAAM;QACN,SAAS;QACT,MAAM,GAAG,KAAK,QAAQ,CAAC;MACzB;MACA;IACF;IAEA,iCAAiC;IACjC,IAAI,CAAC,yBAAyB,KAAK,OAAO,GAAG;MAC3C,OAAO,IAAI,CAAC;QACV,MAAM;QACN,SACE,CAAC,CAAC,EAAE,KAAK,OAAO,CAAC,oFAAoF,CAAC;QACxG,MAAM,GAAG,KAAK,QAAQ,CAAC;MACzB;IACF;IAEA,0CAA0C;IAC1C,IAAI,SAAS,GAAG,CAAC,KAAK,OAAO,GAAG;MAC9B,OAAO,IAAI,CAAC;QACV,MAAM;QACN,SAAS,CAAC,mBAAmB,EAAE,KAAK,OAAO,CAAC,gBAAgB,CAAC;QAC7D,MAAM,GAAG,KAAK,QAAQ,CAAC;MACzB;IACF;IACA,SAAS,GAAG,CAAC,KAAK,OAAO;IAEzB,yBAAyB;IACzB,IAAI,KAAK,WAAW,EAAE,QAAQ;MAC5B,IAAI,mBAAmB,KAAK,WAAW,CAAC,MAAM,GAAG;QAC/C,OAAO,IAAI,CAAC;UACV,MAAM;UACN,SAAS,CAAC,aAAa,EAAE,KAAK,WAAW,CAAC,MAAM,CAAC,0BAA0B,CAAC;UAC5E,MAAM,GAAG,KAAK,mBAAmB,CAAC;QACpC;MACF;IACF;IAEA,mBAAmB;IACnB,IACE,KAAK,WAAW,EAAE,SAClB,CAAC;MAAC;MAAc;MAAmB;KAAc,CAAC,QAAQ,CAAC,KAAK,WAAW,CAAC,KAAK,GACjF;MACA,OAAO,IAAI,CAAC;QACV,MAAM;QACN,SACE,CAAC,eAAe,EAAE,KAAK,WAAW,CAAC,KAAK,CAAC,uDAAuD,CAAC;QACnG,MAAM,GAAG,KAAK,kBAAkB,CAAC;MACnC;IACF;IAEA,8BAA8B;IAC9B,IACE,KAAK,WAAW,EAAE,WAClB,CAAC;MAAC;MAAQ;MAAQ;MAAW;KAAO,CAAC,QAAQ,CAAC,KAAK,WAAW,CAAC,OAAO,GACtE;MACA,OAAO,IAAI,CAAC;QACV,MAAM;QACN,SAAS,CAAC,0BAA0B,EAAE,KAAK,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC;QACjE,MAAM,GAAG,KAAK,oBAAoB,CAAC;MACrC;IACF;EACF;EAEA,8CAA8C;EAC9C,IAAI,SAAS,OAAO,EAAE;IACpB,IAAK,IAAI,KAAK,GAAG,KAAK,SAAS,OAAO,CAAC,MAAM,EAAE,KAAM;MACnD,MAAM,MAAM,SAAS,OAAO,CAAC,GAAG;MAChC,IAAI,IAAI,YAAY,EAAE;QACpB,KAAK,MAAM,WAAW,IAAI,YAAY,CAAE;UACtC,MAAM,QAAQ,SAAS,YAAY,CAAC,IAAI,CACtC,CAAC,IAAM,EAAE,OAAO,KAAK,WAAW,EAAE,SAAS,KAAK;UAElD,IAAI,CAAC,OAAO;YACV,SAAS,IAAI,CAAC;cACZ,MAAM;cACN,SACE,CAAC,+BAA+B,EAAE,QAAQ,wCAAwC,CAAC;cACrF,MAAM,CAAC,QAAQ,EAAE,GAAG,cAAc,CAAC;YACrC;UACF;QACF;MACF;IACF;EACF;EAEA,0DAA0D;EAC1D,KAAK,MAAM,QAAQ,SAAS,YAAY,IAAI,EAAE,CAAE;IAC9C,IAAI,CAAC,KAAK,OAAO,EAAE;IACnB,KAAK,MAAM,eAAe,UAAW;MACnC,IAAI,YAAY,WAAW,KAAK,SAAS,WAAW,EAAE;MACtD,MAAM,WAAW,YAAY,YAAY,CAAC,IAAI,CAAC,CAAC,IAAM,EAAE,OAAO,KAAK,KAAK,OAAO;MAChF,IAAI,UAAU;QACZ,SAAS,IAAI,CAAC;UACZ,MAAM;UACN,SAAS,CAAC,SAAS,EAAE,KAAK,OAAO,CAAC,wBAAwB,EAAE,YAAY,WAAW,EAAE;UACrF,MAAM,CAAC,aAAa,EAAE,SAAS,YAAY,CAAC,OAAO,CAAC,MAAM,SAAS,CAAC;QACtE;MACF;IACF;EACF;EAEA,OAAO;IACL,OAAO,OAAO,MAAM,KAAK;IACzB;IACA;EACF;AACF;AAEA,8DAA8D,GAC9D,OAAO,SAAS;EACd,MAAM,UAAgC,EAAE;EAExC,KAAK,MAAM,OAAO,UAAW;IAC3B,KAAK,MAAM,QAAQ,IAAI,YAAY,CAAE;MACnC,QAAQ,IAAI,CAAC;QACX,SAAS,KAAK,OAAO;QACrB,aAAa,IAAI,WAAW;QAC5B,SAAS,IAAI,OAAO;QACpB,QAAQ,KAAK,WAAW,EAAE;QAC1B,KAAK,KAAK,WAAW,EAAE;QACvB,KAAK,KAAK,WAAW,EAAE;QACvB,SAAS,KAAK,WAAW,EAAE;MAC7B;IACF;EACF;EAEA,QAAQ,IAAI,CAAC,CAAC,GAAG,IAAM,EAAE,OAAO,CAAC,aAAa,CAAC,EAAE,OAAO;EAExD,OAAO;IACL,eAAe,UAAU,MAAM;IAC/B,mBAAmB,QAAQ,MAAM;IACjC;EACF;AACF;AAEA,yDAAyD,GACzD,OAAO,SAAS;EACd,UAAU,MAAM,GAAG;AACrB;AAEA,sEAAsE,GACtE,SAAS,yBAAyB,IAAY;EAC5C,iEAAiE;EACjE,2DAA2D;EAC3D,IAAI,CAAC,MAAM,OAAO;EAClB,MAAM,WAAW,IAAI,IAAI;IACvB;IACA;IACA;IACA;IACA;IACA;IACA;IACA;GACD;EACD,IAAI,SAAS,GAAG,CAAC,OAAO,OAAO;EAC/B,mEAAmE;EACnE,OAAO,8BAA8B,IAAI,CAAC;AAC5C;AAEA,qDAAqD,GACrD,SAAS,mBAAmB,IAAY;EACtC,8EAA8E;EAC9E,IAAI,KAAK,UAAU,CAAC,QAAQ,KAAK,UAAU,CAAC,OAAO,OAAO;EAC1D,IAAI,KAAK,QAAQ,CAAC,OAAO,OAAO;EAChC,IAAI,gBAAgB,IAAI,CAAC,SAAS,CAAC,KAAK,UAAU,CAAC,WAAW,CAAC,KAAK,UAAU,CAAC,SAAS;IACtF,OAAO;EACT;EACA,OAAO;AACT"}

package/src/render-dsd-stream.d.ts

@@ -0,0 +1,46 @@
+import type { RenderError, RenderOutput } from '@openelement/protocol/render';
+export interface RenderDsdStreamChunk {
+  html: string;
+  output: RenderOutput;
+}
+export interface RenderDsdStreamMetrics {
+  chunkCount: number;
+  errorCount: number;
+  startedAt: number;
+  endedAt?: number;
+}
+export interface RenderDsdStreamOptions {
+  shell?: string | (() => string | Promise<string>);
+  footer?: string | (() => string | Promise<string>);
+  onChunk?: (chunk: RenderDsdStreamChunk) => void;
+  onError?: (error: RenderError, tagName: string) => void;
+  metrics?: RenderDsdStreamMetrics;
+}
+export interface RenderDsdStreamComponent {
+  tagName: string;
+  componentClass: CustomElementConstructor;
+  props?: Record<string, unknown>;
+  sourceInfo?: {
+    route?: string;
+    source?: string;
+  };
+  dsdOptions?: import('@openelement/protocol/render').DsdOptions;
+}
+/**
+ * Create a fresh metrics collector for streaming Dsd.
+ */ export declare function createRenderDsdStreamMetrics(): RenderDsdStreamMetrics;
+/**
+ * Render components as a streaming Dsd response.
+ *
+ * Returns a ReadableStream<Uint8Array> that emits:
+ *   1. Shell (opening HTML)
+ *   2. Each component's Dsd output, in order
+ *   3. Footer (closing HTML)
+ *
+ * Failed components emit a bare-tag fallback and the stream continues.
+ * Compatible with Web Response constructor for edge handlers.
+ *
+ * @param components - Iterable of components to render
+ * @param options - Stream options (shell, footer, callbacks, metrics)
+ * @returns ReadableStream of encoded Dsd HTML chunks
+ */ export declare function renderDsdStream(components: Iterable<RenderDsdStreamComponent>, options?: RenderDsdStreamOptions): ReadableStream<Uint8Array>;

package/src/render-dsd-stream.js

@@ -0,0 +1,86 @@
+/**
+ * @openelement/core - Streaming Dsd Renderer.
+ *
+ * Progressive Dsd delivery via Web Streams (ReadableStream<Uint8Array>).
+ * Extracted from render-dsd.ts in v0.21.0 (SOP-003).
+ *
+ * Provides:
+ *   - renderDsdStream() — stream components as they render
+ *   - createRenderDsdStreamMetrics() — metrics collector factory
+ *   - RenderDsdStreamChunk, RenderDsdStreamComponent,
+ *     RenderDsdStreamMetrics, RenderDsdStreamOptions types
+ *
+ * @module @openelement/core/render-dsd-stream
+ */ import { renderDsd, safeNow } from './render-dsd.js';
+const textEncoder = new TextEncoder();
+async function resolveStreamPart(part) {
+  if (!part) return '';
+  return typeof part === 'function' ? await part() : part;
+}
+/**
+ * Create a fresh metrics collector for streaming Dsd.
+ */ export function createRenderDsdStreamMetrics() {
+  return {
+    chunkCount: 0,
+    errorCount: 0,
+    startedAt: safeNow()
+  };
+}
+/**
+ * Render components as a streaming Dsd response.
+ *
+ * Returns a ReadableStream<Uint8Array> that emits:
+ *   1. Shell (opening HTML)
+ *   2. Each component's Dsd output, in order
+ *   3. Footer (closing HTML)
+ *
+ * Failed components emit a bare-tag fallback and the stream continues.
+ * Compatible with Web Response constructor for edge handlers.
+ *
+ * @param components - Iterable of components to render
+ * @param options - Stream options (shell, footer, callbacks, metrics)
+ * @returns ReadableStream of encoded Dsd HTML chunks
+ */ export function renderDsdStream(components, options = {}) {
+  const encoderMetrics = options.metrics ?? createRenderDsdStreamMetrics();
+  return new ReadableStream({
+    async start (controller) {
+      try {
+        const shell = await resolveStreamPart(options.shell);
+        if (shell) {
+          controller.enqueue(textEncoder.encode(shell));
+          encoderMetrics.chunkCount++;
+        }
+        for (const component of components){
+          const output = await renderDsd(component.tagName, {
+            componentClass: component.componentClass,
+            props: component.props ?? {},
+            sourceInfo: component.sourceInfo,
+            dsdOptions: component.dsdOptions
+          });
+          for (const error of output.errors){
+            encoderMetrics.errorCount++;
+            options.onError?.(error, component.tagName);
+          }
+          controller.enqueue(textEncoder.encode(output.html));
+          encoderMetrics.chunkCount++;
+          options.onChunk?.({
+            html: output.html,
+            output
+          });
+        }
+        const footer = await resolveStreamPart(options.footer);
+        if (footer) {
+          controller.enqueue(textEncoder.encode(footer));
+          encoderMetrics.chunkCount++;
+        }
+        encoderMetrics.endedAt = safeNow();
+        controller.close();
+      } catch (error) {
+        encoderMetrics.errorCount++;
+        encoderMetrics.endedAt = safeNow();
+        controller.error(error);
+      }
+    }
+  });
+}
+//# sourceMappingURL=data:application/json;base64,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