@mosetta/runtime 0.0.9 → 0.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mosetta/runtime",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "license": "MIT",
   "description": "mosetta browser runtime: start() (resolver prolog, tree loading, holder), version resolver, safe tile loader, asset runtime. Framework-agnostic — the react mount (startAndMount) lives in @mosetta/react/start. Ships as an ordinary package tile; the root export is the component-facing asset surface.",
   "type": "module",
@@ -17,8 +17,8 @@
     "./naming": "./src/naming.js"
   },
   "dependencies": {
-    "@mosetta/core": "0.0.9",
-    "@mosetta/di": "0.0.9"
+    "@mosetta/core": "0.0.11",
+    "@mosetta/di": "0.0.11"
   },
   "publishConfig": {
     "access": "public"

package/src/bootstrap.ts

@@ -151,11 +151,15 @@ async function run(): Promise<IStartResult> {
   // LOAD path.
   const catalog = new Map<string, ITileDescriptor | null>(Object.entries(realmCatalog));
   const DEP_PREFIX = '_ns_package_t_package_n_';
+  // where an entity outside the catalog was found: beside its importer, or at another tile host the
+  // realm knows — a block of a project's palette placed in the editor is loaded by the workbench's
+  // page, whose slice does not name it
+  const foundAt = new Map<string, string>();
   // an entity lives with the code source its catalog entry names, the host when it names none; an
-  // entity outside the catalog — with the base it was asked from
+  // entity outside the catalog — where its descriptor was found, else the base it was asked from
   const sourceBaseOf = (id: string, pb: string): string => {
     const entry = catalog.get(id) ?? realmCatalog[id];
-    if (!entry) return pb;
+    if (!entry) return foundAt.get(id) ?? pb;
     return (entry.provider ? sources[entry.provider] : base) || pb;
   };
   const entityFileUrl = (id: string, file: string, pb: string): string => new URL('modules/' + id + '/' + file, sourceBaseOf(id, pb)).href; // flat layout
@@ -165,12 +169,24 @@ async function run(): Promise<IStartResult> {
   const sliceIntegrity = (id: string): string | undefined => realmCatalog[id]?.integrity;
   const artifactUrl = (id: string, file: string, pb: string): string => versionedUrl(entityFileUrl(id, file, pb), sliceIntegrity(id));
   const fetched = new Map<string, Promise<ITileDescriptor | null>>();
+  const descriptorAt = (id: string, at: string): Promise<ITileDescriptor | null> => fetch(new URL('modules/' + id + '/' + id + '.json', at).href)
+    .then((r) => (r.ok ? (r.json() as Promise<ITileDescriptor>) : null))
+    .catch(() => null);
+  // an entity outside the catalog: its co-located descriptor beside the base it was asked from, else
+  // at the realm's other tile hosts (the host last) — the first that has it is where it lives
   const entityOf = (id: string, pb: string): Promise<ITileDescriptor | null> => {
     if (catalog.has(id)) return Promise.resolve(catalog.get(id) ?? null);
     if (!fetched.has(id)) {
-      fetched.set(id, fetch(entityFileUrl(id, id + '.json', pb))
-        .then((r) => (r.ok ? (r.json() as Promise<ITileDescriptor>) : null))
-        .catch(() => null));
+      fetched.set(id, (async () => {
+        for (const at of new Set([foundAt.get(id) ?? pb, ...Object.values(sources), base])) {
+          const entity = await descriptorAt(id, at);
+          if (entity) {
+            foundAt.set(id, at);
+            return entity;
+          }
+        }
+        return null;
+      })());
     }
     return fetched.get(id)!;
   };
@@ -299,15 +315,21 @@ async function run(): Promise<IStartResult> {
     getModule: (ref: string): ILoadedTile | undefined => (handedOver.has(ref) ? loader.get(ref) : undefined),
     loadModule: (ref: string, pb?: string): Promise<ILoadedTile> => {
       const ready = handedOver.has(ref) ? loader.get(ref) : undefined;
-      if (ready) return Promise.resolve(ready);
+      if (ready && !ready.error) return Promise.resolve(ready);
       const pending = handing.get(ref);
       if (pending) return pending;
-      const target = pb || providerOf(ref);
-      const handover = Promise.all([ensureCss(ref, target), loader.load(ref, target)]).then(([, loaded]) => {
+      const handover = (async () => {
+        const asked = pb || providerOf(ref);
+        // an entity outside the catalog: found first — its code loads from where its descriptor lies
+        if (!catalog.has(ref) && !realmCatalog[ref]) await entityOf(ref, asked);
+        const target = sourceBaseOf(ref, asked);
+        // a failure before (asked where it does not lie) is tried again
+        loader.forget(ref);
+        const [, loaded] = await Promise.all([ensureCss(ref, target), loader.load(ref, target)]);
         handedOver.add(ref);
         handing.delete(ref);
         return loaded;
-      });
+      })();
       handing.set(ref, handover);
       return handover;
     },