browser-module-runtime 0.0.2 → 0.0.4

package/index.d.ts

@@ -39,6 +39,8 @@ export interface RuntimePlugin {
   cacheKey?: string;
   /** Framework-owned exact package roots merged into the runtime package policy. */
   packageEntries?: NonNullable<PackageOptions['entries']>;
+  /** Optional coordinated package URL family; precedence/conflict validated at factory creation. */
+  packageFamilyRules?: Record<string,{url:string;version:string;provider:string;subpathUrl?:(subpath:string)=>string}>;
   compilers?: CompilerAdapter[];
   renderers?: RendererAdapter[];
   preprocess?: TransformHook[];

package/package.json

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

package/src/index.js

@@ -1,7 +1,8 @@
 import {createRuntime as createModuleEngine} from './engine/runtime.js';
 import {createBuildPipeline} from './build/pipeline.js';
 import {createStyleManager} from './resources/styles.js';
-import {mergePluginPackageEntries} from './plugins/package-entries.js';
+import {mergePluginPackageEntries,mergePluginPackageFamilyRules} from './plugins/package-entries.js';
+import {parsePackageSpecifier,PackageVersionResolutionError} from './engine/package-resolution/index.js';
 
 /** Framework-neutral, synchronous factory. Async plugin setup is available on `.ready`. */
 export function createRuntime(options={}) {
@@ -10,22 +11,35 @@ export function createRuntime(options={}) {
   const metadata=new Map();
   const pipeline=createBuildPipeline({plugins,defaultType:options.defaultType||'javascript',onArtifact:(id,artifact)=>artifactById.set(id,artifact)});
   const effectivePackages=mergePluginPackageEntries(options.packages,plugins);
-  const core=createModuleEngine({...options,packages:effectivePackages,compiler:pipeline});
+  const familyRules=mergePluginPackageFamilyRules(effectivePackages,plugins,options._solidFamilyRules,options.modules);
+  const protectedRoots=new Set(plugins.flatMap(plugin=>Object.keys(plugin.packageFamilyRules??{})));
+  function rejectProtected(id){
+    const name=parsePackageSpecifier(String(id))?.packageName;
+    if(name && protectedRoots.has(name))throw new PackageVersionResolutionError('PACKAGE_VERSION_CONFLICT',
+      `${JSON.stringify(id)} belongs to a framework-managed package family; use host mode to override its modules.`,{packageName:name});
+  }
+  for(const id of Object.keys(options.urls??{}))rejectProtected(id);
+  const core=createModuleEngine({...options,packages:effectivePackages,_solidFamilyRules:familyRules,compiler:pipeline});
   const styles=createStyleManager();
   const mounts=new Set();
   let disposed=false;
   const runtime={
     ...core,
     ready:null,
+    defineModule(id,namespace){rejectProtected(id);return core.defineModule(id,namespace);},
+    defineUrl(id,url){rejectProtected(id);return core.defineUrl(id,url);},
     define(id,source,config={}) {
+      rejectProtected(id);
       const type=pipeline.detectType(id,config.type||config.format);
       metadata.set(id,{type});
       return core.define(id,source,{...config,format:type});
     },
     defineMany(definitions) {
+      definitions.forEach(({id})=>rejectProtected(id));
       return definitions.map(({id,source,...opts})=>runtime.define(id,source,opts));
     },
     update(id,source,config={}) {
+      rejectProtected(id);
       const type=pipeline.detectType(id,config.type||config.format||metadata.get(id)?.type);
       metadata.set(id,{type});
       return core.update(id,source,{...config,format:type});

package/src/plugins/package-entries.js

@@ -28,3 +28,33 @@ export function mergePluginPackageEntries(packages,plugins=[]) {
   }
   return {...source,versions,entries};
 }
+
+
+/** Runtime-local provider rules for package families with strict identity
+ * requirements (e.g. Solid 2). Plugins own their family membership; the
+ * generic module engine only sees a regular root -> URL/subpath resolver map.
+ */
+export function mergePluginPackageFamilyRules(packages, plugins=[], explicitRules={}, modules={}) {
+  const rules={...(explicitRules??{})};
+  const pinned=createPackagePolicy(packages);
+  for(const plugin of plugins){
+    for(const [name,rule] of Object.entries(plugin.packageFamilyRules??{})){
+      const previous=rules[name];
+      if(previous && (previous.url!==rule.url || previous.version!==rule.version))
+        throw new PackageVersionResolutionError('PACKAGE_VERSION_CONFLICT',
+          `Plugin ${JSON.stringify(plugin.name)} requires ${JSON.stringify(name)} from ${rule.url}, but another provider requires ${previous.url}.`,
+          {packageName:name,plugin:plugin.name,expected:rule.url,actual:previous.url});
+      const selected=pinned.inspect(name);
+      if(selected && selected.url!==rule.url)
+        throw new PackageVersionResolutionError('PACKAGE_VERSION_CONFLICT',
+          `Plugin ${JSON.stringify(plugin.name)} owns ${JSON.stringify(name)} at ${rule.url}, but the runtime pins ${selected.url}. Remove the duplicate family pin.`,
+          {packageName:name,plugin:plugin.name,expected:rule.url,actual:selected.url});
+      if(Object.hasOwn(modules,name))
+        throw new PackageVersionResolutionError('PACKAGE_VERSION_CONFLICT',
+          `Plugin ${JSON.stringify(plugin.name)} owns ${JSON.stringify(name)}; a caller-owned module namespace cannot guarantee the same framework identity. Use host mode.`,
+          {packageName:name,plugin:plugin.name});
+      rules[name]=rule;
+    }
+  }
+  return rules;
+}