@asteby/metacore-runtime-react 15.0.0 → 16.0.1

package/CHANGELOG.md

@@ -1,5 +1,47 @@
 # @asteby/metacore-runtime-react
 
+## 16.0.1
+
+### Patch Changes
+
+- cde025c: Fix intermittent `#RUNTIME-009` ("Please call createInstance first") addon load
+  errors.
+
+  When an addon mounts before `@module-federation/vite`'s asynchronous runtime
+  init lands at host boot, `registerRemotes`/`loadRemote` throw RUNTIME-009. The
+  runtime is on its way — it's a boot race — so `AddonLoader` now treats that
+  specific error as transient and retries with a short backoff (~10 × 60ms) until
+  the host's federation runtime is ready, instead of surfacing a dead "Addon load
+  error" to the user. Genuine failures (bad URL, missing export, 404) still
+  rethrow immediately.
+
+## 16.0.0
+
+### Minor Changes
+
+- 5f864d9: Make declarative dynamic-table option badges and relation chips feel alive.
+
+  Options/select/status badges that ship without an explicit `color` from the
+  backend now get a deterministic, cohesive color derived from the option value
+  (fallback label) instead of rendering as dead gray text. Same value always maps
+  to the same hue, and equal words share a color.
+  - `@asteby/metacore-ui/lib` adds `optionColor(key)` (curated 16-hue Tailwind-500
+    palette, FNV-1a hash, light/dark safe), plus `optionColorBadgeStyles`,
+    `relationChipStyles`, and the exported `OPTION_PALETTE`.
+  - `OptionBadge` uses the explicit `color` when present, otherwise derives one via
+    `optionColor`, and renders the option's lucide `icon` before the label.
+  - `RelationCell` (resolved FK chips for category/brand/supplier/…) now gets a
+    subtle deterministic color keyed on the related label — kept lighter than enum
+    badges (soft tint, no heavy fill) so the two remain distinguishable.
+
+  All colors come from hex-derived inline styles, so they render correctly
+  regardless of the host's tailwind safelist.
+
+### Patch Changes
+
+- Updated dependencies [5f864d9]
+  - @asteby/metacore-ui@2.4.0
+
 ## 15.0.0
 
 ### Minor Changes

package/dist/addon-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"addon-loader.d.ts","sourceRoot":"","sources":["../src/addon-loader.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAGjE,MAAM,WAAW,gBAAgB;IAC7B,uEAAuE;IACvE,KAAK,EAAE,MAAM,CAAA;IACb,+EAA+E;IAC/E,GAAG,EAAE,MAAM,CAAA;IACX,oEAAoE;IACpE,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,+DAA+D;IAC/D,GAAG,EAAE,QAAQ,CAAA;IACb,wCAAwC;IACxC,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC1B,yDAAyD;IACzD,OAAO,CAAC,EAAE,MAAM,IAAI,CAAA;IACpB,+BAA+B;IAC/B,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,CAAA;IAC9B;;;;;;;;;;OAUG;IACH,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;CAC7B;AA6CD,wBAAgB,WAAW,CAAC,EACxB,KAAK,EACL,GAAG,EACH,MAAqB,EACrB,GAAG,EACH,QAAe,EACf,OAAO,EACP,OAAO,EACP,MAAM,EACN,QAAQ,GACX,EAAE,gBAAgB,2CA8ClB"}
+{"version":3,"file":"addon-loader.d.ts","sourceRoot":"","sources":["../src/addon-loader.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAGjE,MAAM,WAAW,gBAAgB;IAC7B,uEAAuE;IACvE,KAAK,EAAE,MAAM,CAAA;IACb,+EAA+E;IAC/E,GAAG,EAAE,MAAM,CAAA;IACX,oEAAoE;IACpE,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,+DAA+D;IAC/D,GAAG,EAAE,QAAQ,CAAA;IACb,wCAAwC;IACxC,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC1B,yDAAyD;IACzD,OAAO,CAAC,EAAE,MAAM,IAAI,CAAA;IACpB,+BAA+B;IAC/B,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,CAAA;IAC9B;;;;;;;;;;OAUG;IACH,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;CAC7B;AAoFD,wBAAgB,WAAW,CAAC,EACxB,KAAK,EACL,GAAG,EACH,MAAqB,EACrB,GAAG,EACH,QAAe,EACf,OAAO,EACP,OAAO,EACP,MAAM,EACN,QAAQ,GACX,EAAE,gBAAgB,2CA8ClB"}

package/dist/addon-loader.js

@@ -25,22 +25,56 @@ function remoteId(scope, module) {
     const expose = module.replace(/^\.\//, '');
     return `${scope}/${expose}`;
 }
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+// `@module-federation/vite` initialises the shared federation runtime instance
+// asynchronously at host boot (it injects an init call into the entry). If an
+// addon mounts before that init resolves — a real race on slow first paints,
+// route preloads, or HMR — `registerRemotes`/`loadRemote` throw
+// `[ Federation Runtime ]: Please call createInstance first. #RUNTIME-009`.
+// It's transient: the runtime IS coming, we just raced it. So we treat
+// RUNTIME-009 specifically as retryable and back off briefly until the host's
+// init lands, instead of surfacing a dead "Addon load error" to the user.
+function isRuntimeNotReady(e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return msg.includes('#RUNTIME-009') || msg.includes('call createInstance');
+}
+// Retry an operation that may hit the boot race above. ~10 attempts × 60ms ≈
+// 600ms worst case — generous for the host init, imperceptible in the common
+// case (first attempt succeeds). Non-RUNTIME-009 errors (bad URL, 404, no
+// export) rethrow immediately so genuine failures still surface fast.
+async function withRuntimeReady(op) {
+    const maxAttempts = 10;
+    for (let attempt = 1;; attempt++) {
+        try {
+            return await op();
+        }
+        catch (e) {
+            if (!isRuntimeNotReady(e) || attempt >= maxAttempts)
+                throw e;
+            await sleep(60);
+        }
+    }
+}
 async function loadAddon(scope, url, module) {
     // Register the remote container as an ES module. `type: 'module'` matches
     // the `@module-federation/vite` remote (remoteEntry.js is an ESM bundle).
     // The `url` already carries the `?v=` cache-bust the host computed, so the
     // browser refetches a fresh remoteEntry when the addon version changes.
+    //
+    // Both calls are wrapped in `withRuntimeReady` because EITHER can throw
+    // RUNTIME-009 when an addon mounts ahead of the host's federation init —
+    // registration is what actually touches the (maybe-uninitialised) runtime.
     if (!registered.has(scope)) {
-        registerRemotes([{ name: scope, entry: url, type: 'module' }], 
+        await withRuntimeReady(() => registerRemotes([{ name: scope, entry: url, type: 'module' }], 
         // `force: true` so a re-registration with a new `?v=` URL (addon
         // hot-swap / version bump) overwrites the stale entry + cache.
-        { force: true });
+        { force: true }));
         registered.add(scope);
     }
     // loadRemote("<scope>/<expose>") returns the exposed module namespace (or
     // null if it can't be resolved). No manual share-scope init — the host's
     // federation runtime already initialised it.
-    return loadRemote(remoteId(scope, module));
+    return withRuntimeReady(() => loadRemote(remoteId(scope, module)));
 }
 export function AddonLoader({ scope, url, module = './register', api, fallback = null, onReady, onError, layout, children, }) {
     const [status, setStatus] = useState('loading');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asteby/metacore-runtime-react",
-  "version": "15.0.0",
+  "version": "16.0.1",
   "description": "React runtime for metacore hosts — renders addon contributions dynamically",
   "repository": {
     "type": "git",
@@ -34,7 +34,7 @@
     "date-fns": ">=3",
     "react-day-picker": ">=8",
     "@asteby/metacore-sdk": "^3.1.0",
-    "@asteby/metacore-ui": "^2.3.0"
+    "@asteby/metacore-ui": "^2.4.0"
   },
   "peerDependenciesMeta": {
     "@tanstack/react-router": {
@@ -61,8 +61,8 @@
     "typescript": "^6.0.0",
     "vitest": "^4.0.0",
     "zustand": "^5.0.0",
-    "@asteby/metacore-sdk": "3.1.0",
-    "@asteby/metacore-ui": "2.3.0"
+    "@asteby/metacore-ui": "2.4.0",
+    "@asteby/metacore-sdk": "3.1.0"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",

package/src/addon-loader.tsx

@@ -64,6 +64,37 @@ function remoteId(scope: string, module: string): string {
     return `${scope}/${expose}`
 }
 
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms))
+
+// `@module-federation/vite` initialises the shared federation runtime instance
+// asynchronously at host boot (it injects an init call into the entry). If an
+// addon mounts before that init resolves — a real race on slow first paints,
+// route preloads, or HMR — `registerRemotes`/`loadRemote` throw
+// `[ Federation Runtime ]: Please call createInstance first. #RUNTIME-009`.
+// It's transient: the runtime IS coming, we just raced it. So we treat
+// RUNTIME-009 specifically as retryable and back off briefly until the host's
+// init lands, instead of surfacing a dead "Addon load error" to the user.
+function isRuntimeNotReady(e: unknown): boolean {
+    const msg = e instanceof Error ? e.message : String(e)
+    return msg.includes('#RUNTIME-009') || msg.includes('call createInstance')
+}
+
+// Retry an operation that may hit the boot race above. ~10 attempts × 60ms ≈
+// 600ms worst case — generous for the host init, imperceptible in the common
+// case (first attempt succeeds). Non-RUNTIME-009 errors (bad URL, 404, no
+// export) rethrow immediately so genuine failures still surface fast.
+async function withRuntimeReady<T>(op: () => T | Promise<T>): Promise<T> {
+    const maxAttempts = 10
+    for (let attempt = 1; ; attempt++) {
+        try {
+            return await op()
+        } catch (e) {
+            if (!isRuntimeNotReady(e) || attempt >= maxAttempts) throw e
+            await sleep(60)
+        }
+    }
+}
+
 async function loadAddon(
     scope: string,
     url: string,
@@ -73,19 +104,27 @@ async function loadAddon(
     // the `@module-federation/vite` remote (remoteEntry.js is an ESM bundle).
     // The `url` already carries the `?v=` cache-bust the host computed, so the
     // browser refetches a fresh remoteEntry when the addon version changes.
+    //
+    // Both calls are wrapped in `withRuntimeReady` because EITHER can throw
+    // RUNTIME-009 when an addon mounts ahead of the host's federation init —
+    // registration is what actually touches the (maybe-uninitialised) runtime.
     if (!registered.has(scope)) {
-        registerRemotes(
-            [{ name: scope, entry: url, type: 'module' }],
-            // `force: true` so a re-registration with a new `?v=` URL (addon
-            // hot-swap / version bump) overwrites the stale entry + cache.
-            { force: true },
+        await withRuntimeReady(() =>
+            registerRemotes(
+                [{ name: scope, entry: url, type: 'module' }],
+                // `force: true` so a re-registration with a new `?v=` URL (addon
+                // hot-swap / version bump) overwrites the stale entry + cache.
+                { force: true },
+            ),
         )
         registered.add(scope)
     }
     // loadRemote("<scope>/<expose>") returns the exposed module namespace (or
     // null if it can't be resolved). No manual share-scope init — the host's
     // federation runtime already initialised it.
-    return loadRemote<AddonRegisterModule>(remoteId(scope, module))
+    return withRuntimeReady(() =>
+        loadRemote<AddonRegisterModule>(remoteId(scope, module)),
+    )
 }
 
 export function AddonLoader({