browser-module-runtime 0.0.7 → 0.0.8

package/README.md

@@ -5,7 +5,7 @@ A framework-neutral browser module runtime with a native ESM linker, independent
 ## Install
 
 ```sh
-npm install browser-module-runtime@0.0.7
+npm install browser-module-runtime@0.0.8
 ```
 
 ## Define, import and update modules
@@ -59,7 +59,7 @@ await handle.dispose();
 ### Public exports
 
 - `browser-module-runtime`: runtime, build pipeline, cache and resolver utilities
-- `browser-module-runtime/html`: `registerHTML` and generic `<runtime-render>` integration
+- `browser-module-runtime/html`: `createHTMLRuntime` and generic `<runtime-render>` integration
 - `browser-module-runtime/packages`: package policy utilities
 - `browser-module-runtime/cache`: compile-cache implementations
 
@@ -68,8 +68,8 @@ await handle.dispose();
 ### Scoped HTML (development branch)
 
 ```js
-import {registerHTML} from 'browser-module-runtime/html';
-registerHTML(runtime,{scope:'app',root:document}); // No initial scan or observer
+import {createHTMLRuntime} from 'browser-module-runtime/html';
+createHTMLRuntime(runtime,{scope:'app',root:document}); // No initial scan or observer
 ```
 
 ```html

package/html.d.ts

@@ -1,8 +1,6 @@
 import type {Runtime} from './index.js';
 import type {WebComponentOptions} from './web-components.js';
 export interface HTMLController {
-  /** Scope name; `name` is a backwards compatible alias. */
-  readonly name:string;
   readonly scope:string;
   readonly root:Document|Element;
   readonly appendTarget:Document|Element;
@@ -16,18 +14,12 @@ export interface HTMLController {
   appendAndRegister(script:HTMLScriptElement,target?:Document|Element):Promise<HTMLScriptElement>;
   /** Preferred explicit, repeatable processing of existing source declarations. */
   process():Promise<void>;
-  /** @deprecated Use process(). */
-  registerExisting():Promise<void>;
-  /** @deprecated Use process(). */
-  scan():Promise<void>;
-  setRoot(root:Document|Element,options?:{processExisting?:boolean;registerExisting?:boolean}):Promise<Document|Element>;
-  moveTo(root:Document|Element,options?:{processExisting?:boolean;registerExisting?:boolean}):Promise<Document|Element>;
+  setRoot(root:Document|Element,options?:{processExisting?:boolean}):Promise<Document|Element>;
+  moveTo(root:Document|Element,options?:{processExisting?:boolean}):Promise<Document|Element>;
   disconnect():Promise<void>;
 }
-export interface RegisterHTMLOptions {
+export interface HTMLRuntimeOptions {
   scope?:string;
-  /** Backward compatible alias for scope. */
-  name?:string;
   root?:Document|Element;
   /** Whether an element without an explicit scope can be owned by this controller. */
   acceptUnscoped?:boolean;
@@ -35,9 +27,9 @@ export interface RegisterHTMLOptions {
   observe?:boolean;
 }
 /** Does not scan automatically. <runtime-render> itself is an autonomous custom element. */
-export declare function registerHTML(runtime:Runtime,options?:RegisterHTMLOptions):HTMLController;
+export declare function createHTMLRuntime(runtime:Runtime,options?:HTMLRuntimeOptions):HTMLController;
 
 /** High-level one-shot HTML discovery. Registers the controller and processes existing inert scripts.
  * Returns the controller for subsequent root, observer and lifecycle operations.
  */
-export declare function processHTML(runtime:Runtime,options?:RegisterHTMLOptions):Promise<HTMLController>;
+export declare function processHTML(runtime:Runtime,options?:HTMLRuntimeOptions):Promise<HTMLController>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "browser-module-runtime",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "type": "module",
   "exports": {
     ".": {

package/src/html/index.js

@@ -118,14 +118,14 @@ function defineAutonomousElements(doc){
 }
 let sequence=0;
 /** Register a scoped HTML controller. Never scans automatically. */
-export function registerHTML(runtime,options={}){
-  const {name,scope,root=globalThis.document,observe=false,acceptUnscoped=true}=options;
-  if(!root)throw new TypeError('registerHTML requires a DOM root');
+export function createHTMLRuntime(runtime,options={}){
+  const {scope="default",root=globalThis.document,observe=false,acceptUnscoped=true}=options;
+  if(!root)throw new TypeError('createHTMLRuntime requires a DOM root');
   const doc=rootDocument(root);
-  if(!doc)throw new TypeError('registerHTML root must belong to a document');
+  if(!doc)throw new TypeError('createHTMLRuntime root must belong to a document');
   const registry=getScopeRegistry(doc);
   defineAutonomousElements(doc);
-  const resolvedScope=scope||name||'default';
+  const resolvedScope=scope;
   let alive=true,observer=null,currentRoot=root,appendTarget=root,pending=Promise.resolve();
   const controller={id:++sequence,scope:resolvedScope,get root(){return currentRoot;},acceptUnscoped,runtime,get alive(){return alive;},defineElement};
   function defineElement(tag,config){return registerWebComponent(runtime,{...config,tag,document:doc});}
@@ -174,13 +174,11 @@ export function registerHTML(runtime,options={}){
     await registerScript(script);
     return script;
   }
-  async function setRoot(nextRoot,{processExisting,registerExisting=false}={}){
-    // processExisting is preferred; registerExisting remains a legacy alias.
-    const shouldProcess=processExisting??registerExisting;
+  async function setRoot(nextRoot,{processExisting=false}={}){
     if(!alive)throw new Error('HTML controller is disconnected');
     if(rootDocument(nextRoot)!==doc)throw new Error('HTML root must remain in the same document');
     if(observer)observer.disconnect();currentRoot=nextRoot;registry.notify();enableObservation();
-    if(shouldProcess)await scheduleScan();
+    if(processExisting)await scheduleScan();
     return nextRoot;
   }
   async function moveTo(nextRoot,opts){const moved=await setRoot(nextRoot,opts);appendTarget=nextRoot;return moved;}
@@ -191,15 +189,15 @@ export function registerHTML(runtime,options={}){
   }
   registry.add(controller);
   enableObservation();
-  return {name:resolvedScope,scope:resolvedScope,runtime,defineElement,registerScript,appendScript,appendAndRegister,process:scheduleScan,registerExisting:scheduleScan,scan:scheduleScan,setRoot,moveTo,disconnect,get root(){return currentRoot;},get appendTarget(){return appendTarget;}};
+  return {scope:resolvedScope,runtime,defineElement,registerScript,appendScript,appendAndRegister,process:scheduleScan,setRoot,moveTo,disconnect,get root(){return currentRoot;},get appendTarget(){return appendTarget;}};
 }
 
 /** Create a scoped HTML controller and process existing source declarations once.
- * Unlike registerHTML(), this convenience function explicitly performs discovery.
+ * Unlike createHTMLRuntime(), this convenience function explicitly performs discovery.
  * Returns the controller so callers can use appendAndRegister(), setRoot() or disconnect().
  */
 export async function processHTML(runtime,options={}){
-  const controller=registerHTML(runtime,options);
+  const controller=createHTMLRuntime(runtime,options);
   try{
     await controller.process();
     return controller;