@arcote.tech/arc 0.7.16 → 0.7.18

package/dist/adapters/index.d.ts

@@ -10,6 +10,8 @@
  */
 export { AuthAdapter } from "./auth-adapter";
 export type { DecodedToken } from "./auth-adapter";
+export { awaitModuleSync, hasModuleSyncProvider, registerModuleSyncProvider, triggerModuleSync, } from "./module-sync-coordinator";
+export type { ModuleSyncProvider } from "./module-sync-coordinator";
 export { CommandWire } from "./command-wire";
 export { EventWire } from "./event-wire";
 export type { QuerySubscriptionCallbacks, ReceivedEvent, SyncableEvent, } from "./event-wire";

package/dist/adapters/module-sync-coordinator.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Module-sync coordinator — neutral seam letting token-setters (core/react)
+ * await the platform module loader WITHOUT core/react depending on platform.
+ *
+ * Token-gated code-splitting: setting a scope token must dynamically import
+ * that token's module chunks before routes inside them exist. The loader
+ * lives in the platform layer; setToken lives in core/react. This singleton
+ * is the bridge: platform's useModuleLoader registers a provider (runs
+ * syncModules), and setToken triggers a sync + returns a promise that
+ * resolves when the LATEST sync finishes.
+ *
+ * With no provider registered (server, SSR, tests, app-without-platform)
+ * every call resolves immediately — preserving the historical synchronous
+ * semantics. It NEVER rejects: a hung/failed sync resolves after a bounded
+ * timeout so navigation always proceeds.
+ */
+export type ModuleSyncProvider = (scope?: string) => Promise<void>;
+/**
+ * Register the function that performs a module sync. Returns an unregister fn.
+ * Last registration wins (only one platform loader is ever mounted).
+ */
+export declare function registerModuleSyncProvider(fn: ModuleSyncProvider): () => void;
+export declare function hasModuleSyncProvider(): boolean;
+/**
+ * Trigger a sync through the registered provider; resolve when it finishes
+ * (or after `timeoutMs`). Coalesces concurrent calls — the published
+ * `latestSync` tracks the newest invocation.
+ *
+ * - No provider → resolves immediately (sync semantics preserved).
+ * - Provider hangs → resolves (never rejects) after `timeoutMs` + a warning.
+ * - Provider throws → resolves (never rejects) + a warning; the loader
+ *   surfaces its own error state. setToken must not throw on module-load fail.
+ */
+export declare function triggerModuleSync(scope?: string, timeoutMs?: number): Promise<void>;
+/**
+ * Await the most recent sync without triggering a new one. Resolves
+ * immediately when nothing is in flight.
+ */
+export declare function awaitModuleSync(): Promise<void>;
+//# sourceMappingURL=module-sync-coordinator.d.ts.map

package/dist/adapters/module-sync-coordinator.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=module-sync-coordinator.test.d.ts.map

package/dist/index.js

@@ -119,6 +119,56 @@ class AuthAdapter {
     this.scopes.clear();
   }
 }
+// src/adapters/module-sync-coordinator.ts
+var DEFAULT_TIMEOUT_MS = 8000;
+var provider = null;
+var latestSync = null;
+var syncSeq = 0;
+function registerModuleSyncProvider(fn) {
+  provider = fn;
+  return () => {
+    if (provider === fn)
+      provider = null;
+  };
+}
+function hasModuleSyncProvider() {
+  return provider !== null;
+}
+function triggerModuleSync(scope, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  if (!provider) {
+    latestSync = Promise.resolve();
+    return latestSync;
+  }
+  const seq = ++syncSeq;
+  const run = (async () => {
+    try {
+      await provider(scope);
+    } catch (err) {
+      console.warn("[arc] module sync failed during setToken:", err);
+    }
+  })();
+  const guarded = new Promise((resolve) => {
+    let settled = false;
+    const done = () => {
+      if (settled)
+        return;
+      settled = true;
+      resolve();
+    };
+    const timer = setTimeout(() => {
+      console.warn(`[arc] module sync did not complete within ${timeoutMs}ms; proceeding anyway.`);
+      done();
+    }, timeoutMs);
+    timer?.unref?.();
+    run.then(done, done).finally(() => clearTimeout(timer));
+  });
+  if (seq === syncSeq)
+    latestSync = guarded;
+  return guarded;
+}
+function awaitModuleSync() {
+  return latestSync ?? Promise.resolve();
+}
 // src/adapters/wire.ts
 class Wire {
   baseUrl;
@@ -4452,6 +4502,7 @@ class ScopedModel {
     for (const listener4 of this.tokenListeners) {
       listener4();
     }
+    return triggerModuleSync(this.scopeName);
   }
   getToken() {
     return this.authAdapter.getToken();
@@ -5250,6 +5301,7 @@ class TokenCache {
 }
 export {
   view,
+  triggerModuleSync,
   token,
   stringEnum,
   string,
@@ -5257,6 +5309,7 @@ export {
   secureDataStorage,
   route,
   resolveQueryChange,
+  registerModuleSyncProvider,
   record,
   or,
   observeQueries,
@@ -5267,6 +5320,7 @@ export {
   mergeUnsafe,
   listener,
   id,
+  hasModuleSyncProvider,
   file,
   extractDatabaseAgnosticSchema,
   executeDescriptor,
@@ -5285,6 +5339,7 @@ export {
   buildContextAccessor,
   boolean,
   blob,
+  awaitModuleSync,
   array,
   arcFunctionWithCtx,
   arcFunction,

package/dist/model/scoped-model.d.ts

@@ -21,7 +21,15 @@ export declare class ScopedModel<Context extends ArcContextAny> implements Model
     private readonly scopedAdapters;
     private tokenListeners;
     constructor(parent: ModelLike<Context>, scopeName: string);
-    setToken(token: string | null): void;
+    /**
+     * Set this scope's token. Returns a promise that resolves when the platform
+     * module loader has synced the chunks for the new token state (so routes in
+     * newly-gated modules exist before the caller navigates). With no module-sync
+     * provider registered (server, SSR, tests, app-without-platform) it resolves
+     * immediately — preserving the historical synchronous semantics for the many
+     * server-side `setToken(rawToken)` callers that ignore the return value.
+     */
+    setToken(token: string | null): Promise<void>;
     getToken(): string | null;
     getDecoded(): DecodedToken | null;
     getParams(): Record<string, any> | null;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arcote.tech/arc",
   "type": "module",
-  "version": "0.7.16",
+  "version": "0.7.18",
   "private": false,
   "author": "Przemysław Krasiński [arcote.tech]",
   "description": "Arc framework core rewrite with improved event emission and type safety",