arcane-os 0.7.0 → 0.7.2

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## 0.7.2
+
+- Keep both supported browser NPU and GPU flag address copy controls available
+  regardless of API availability, GPU classification, or detection failure.
+  Use one short explanation per flag and one shared paste/enable/relaunch
+  instruction. Preserve browser-reported statuses and the GPU-only chat notice.
+
+## 0.7.1
+
+- Make Profile NPU and GPU setup concise and copy-only, with **Copy NPU flag
+  address** as the NPU action. Confirm a reported discrete GPU with **Already
+  using the performance GPU.** and show GPU setup only for explicitly reported
+  integrated or software adapters. Unknown GPU classes receive no flag advice.
+- Retain the loaded Wllama Worker's adapter details for the GPU-only chat alert.
+  Show that alert only for an explicitly reported integrated or software adapter,
+  with manual browser-address instructions and no attempted navigation.
+- Preserve complete adapter descriptions and optional class/fallback metadata
+  through the Wllama projection. Remove obsolete projection identity gates.
+- Forward speech artifact and upstream model loading progress through sticky AI
+  state. Show the current file, completed files, elapsed time, and initialization
+  in both transcription controls, with indeterminate progress for unknown totals.
+  Preserve cancellation, complete diagnostics, models, and inference precision.
+
 ## 0.7.0
 
 - Add `arcane dev --public`, including forwarding through

package/NOTICE

@@ -8,27 +8,24 @@ informational notice and is not itself a grant of commercial rights.
 Third-party material retains its own terms:
 
 - event-pubsub 6.1.0: MIT License; see its installed `licence` file.
-- strong-type 2.0.0: MIT License; see its installed `licence` file.
+- strong-type 2.0.1: MIT License; see its installed `licence` file.
 - vanilla-test 2.1.3: MIT License; see its installed `licence` file.
 - ansi-colors-es6 5.0.0: MIT License; see its installed `LICENSE` file.
 - vanilla-test's strong-type 2.0.1 dependency: MIT License; see its installed
   `licence` file.
-- bundled strong-type 1.1.0: MIT License; see runtime/strong-type/licence.
+- bundled strong-type 2.0.1: MIT License; see runtime/strong-type/licence.
 - uPlot: MIT License; see runtime/arcane/modules/uPlot.LICENSE.txt.
 - @wllama/wllama 3.6.0 (source revision
   f16050d8d51a00602c6a2a6b8ac9c09f490eea7f): MIT License; see
   browser-runtime/ai/wllama/LICENCE.
 - llama.cpp b10454 (source revision
-  4df29be4f4c3673f428170fda944a5b19f743bb8), embedded in the authenticated
+  4df29be4f4c3673f428170fda944a5b19f743bb8), embedded in the
   Wllama runtime: MIT License; see browser-runtime/ai/wllama/llama.cpp-LICENSE.
 - Marked: MIT License; complete notice and terms reproduced below.
 - QRCode.js: MIT License; complete notice and terms reproduced below.
 
-No model weights, speech runtimes, or speech model/voice bytes are included in
-this package. Browser model and speech downloads require caller-supplied
-authorities. Byte-length and SHA-256 checks inherit the app security policy,
-default to disabled, and may be enabled or overridden for one provider/load;
-an enabled check requires its expected value before cache admission.
+No model weights, speech runtimes, or speech model/voice files are included in
+this package. Browser models and speech resources use their upstream downloads.
 
 Marked
 ------
@@ -57,9 +54,7 @@ SOFTWARE.
 QRCode.js
 ---------
 
-runtime/arcane/modules/QRCode.min.js is byte-for-byte the qrcode.min.js file
-from the davidshimjs/qrcodejs master branch. Its SHA-256 is
-c541ef06327885a8415bca8df6071e14189b4855336def4f36db54bde8484f36.
+runtime/arcane/modules/QRCode.min.js comes from davidshimjs/qrcodejs.
 
 Copyright (c) 2012 davidshimjs
 

package/README.md

@@ -19,7 +19,7 @@ version-locked SDK runtime, while an integrated Arcane checkout uses its live
 `arcane/` runtime. Both profiles preserve the same app URLs, theme, packaging,
 event, cancellation, and browser run contracts.
 
-This checkout defines the `0.7.0` SDK contract. Applications pin one exact npm
+This checkout defines the `0.7.2` SDK contract. Applications pin one exact npm
 version and lockfile; registry state is deliberately not baked into application
 artifacts.
 
@@ -35,7 +35,7 @@ Create one browser application, install its pinned SDK, and start its source
 server:
 
 ```bash
-npx arcane-os@0.7.0 new hello-speech --path ./hello-speech --target browser
+npx arcane-os@0.7.2 new hello-speech --path ./hello-speech --target browser
 cd hello-speech
 npm install
 npm run dev
@@ -378,7 +378,7 @@ uses the same controller for automatic memory extraction.
 Create a new repository-shaped Arcane application with the exact stable SDK:
 
 ```bash
-npx arcane-os@0.7.0 new my-app --path ./my-app --target portable --git
+npx arcane-os@0.7.2 new my-app --path ./my-app --target portable --git
 cd my-app
 npm install
 npm run dev
@@ -388,7 +388,7 @@ To enroll an existing repository, install the exact SDK and initialize only
 missing Arcane files:
 
 ```bash
-npm install --save-dev --save-exact arcane-os@0.7.0
+npm install --save-dev --save-exact arcane-os@0.7.2
 npm exec -- arcane init my-app --target portable
 ```
 
@@ -404,7 +404,7 @@ npm exec -- arcane-os targets
 No global SDK install or standalone Arcane CLI is required. The application
 repository's exact npm dependency and lockfile own the CLI and toolchain version.
 
-Use `npx arcane-os@0.7.0` for the initial bootstrap because it names this npm
+Use `npx arcane-os@0.7.2` for the initial bootstrap because it names this npm
 package explicitly; bare `npx arcane` outside an installed project could resolve
 a different package. Both installed commands invoke the same headless toolchain.
 Project-local npm scripts use the SDK pinned by that app's `package-lock.json`,
@@ -424,7 +424,7 @@ node ./bin/arcane.mjs new local-app --path ../local-app --target portable --git
 
 # From the generated app repository
 cd ../local-app
-npm install --save-dev --save-exact ../arcane-os-sdk/arcane-os-0.7.0.tgz
+npm install --save-dev --save-exact ../arcane-os-sdk/arcane-os-0.7.2.tgz
 npm ci
 ```
 
@@ -433,7 +433,7 @@ same location. The lockfile retains the selected package dependency while
 Arcane uses the installed package name and version. Local directory `file:` dependencies are not
 accepted because npm may install them as links; use a packed `.tgz`. A GitHub
 runner also needs that tarball at the locked path. After publication, replace
-the local declaration with the exact `arcane-os@0.7.0` registry package and
+the local declaration with the exact `arcane-os@0.7.2` registry package and
 commit the regenerated lock.
 
 Generated repositories use `npm ci --ignore-scripts` in CI. Run dependency
@@ -572,7 +572,7 @@ package installation, or assertions.
 
 ## Current target support
 
-Version `0.7.0` exposes one browser target and five explicitly paired
+Version `0.7.2` exposes one browser target and five explicitly paired
 native development targets: a non-runnable portable directory, a
 Windows x64 unsigned-local-test EXE bundle, Linux x64 and Linux ARM64
 unsigned-local-test DEBs, and an Android development-signed APK. The

package/browser-runtime/ai/browser-device-settings.mjs

@@ -7,17 +7,6 @@ export const WEBNN_BROWSER_SETTINGS = [
   { browserId: "edge", name: "Microsoft Edge", url: "edge://flags/#web-machine-learning-neural-network" },
 ];
 
-// Internal-page navigation may be blocked. The instructions remain available
-// regardless; returning from this function is not evidence that settings opened.
-export function openBrowserDeviceSettings(target, message) {
-  try {
-    globalThis.open?.(target.url, "_blank", "noopener,noreferrer");
-  } catch {
-    // Continue to the address-bar instructions when the browser rejects the URL.
-  }
-  globalThis.alert?.(message);
-}
-
 // Browser identity selects setup instructions, never hardware or model readiness.
 export function getBrowserDeviceSettings(navigatorObject = globalThis.navigator) {
   const userAgent = String(navigatorObject?.userAgent ?? "");
@@ -83,22 +72,37 @@ export function getBrowserDeviceSettings(navigatorObject = globalThis.navigator)
   };
 }
 
-// Adapter selection is availability evidence, not the browser flag's state or
-// proof that a model is executing on this GPU. The power preference is a hint.
+// Only an explicit browser adapter type or fallback flag establishes its class.
+// Vendor names and powerPreference (including Chromium's echoed request) do not.
+export function describeBrowserGpu(info, legacyFallbackAdapter) {
+    const adapterType = is.string(info?.type) ? info.type : null;
+    const isFallbackAdapter = is.boolean(info?.isFallbackAdapter)
+        ? info.isFallbackAdapter
+        : is.boolean(legacyFallbackAdapter) ? legacyFallbackAdapter : null;
+    let performanceStatus = 'unknown';
+    if (isFallbackAdapter === true || adapterType === 'CPU') performanceStatus = 'fallback';
+    else if (adapterType === 'discrete GPU') performanceStatus = 'discrete';
+    else if (adapterType === 'integrated GPU') performanceStatus = 'integrated';
+    return {
+        name: info?.description || info?.name
+            || [info?.vendor, info?.architecture, info?.device].filter(Boolean).join(' ')
+            || 'WebGPU adapter',
+        adapterType,
+        isFallbackAdapter,
+        performanceStatus
+    };
+}
+
+// This is the adapter returned to this page, not another page's model adapter.
+// Requesting high performance is a hint, not evidence that it was honored.
 export async function detectBrowserGpu(navigatorObject = globalThis.navigator) {
   if (!is.function(navigatorObject?.gpu?.requestAdapter)) {
     return { available: false, reason: "api-unavailable" };
   }
   const adapter = await navigatorObject.gpu.requestAdapter({ powerPreference: "high-performance" });
   if (!adapter) return { available: false, reason: "adapter-unavailable" };
-  const info = adapter.info;
   return {
     available: true,
-    name: info?.description
-      || [info?.vendor, info?.architecture, info?.device].filter(Boolean).join(" ")
-      || "WebGPU adapter",
-    isFallbackAdapter: is.boolean(info?.isFallbackAdapter)
-      ? info.isFallbackAdapter
-      : is.boolean(adapter.isFallbackAdapter) ? adapter.isFallbackAdapter : null,
+    ...describeBrowserGpu(adapter.info, adapter.isFallbackAdapter),
   };
 }

package/browser-runtime/ai/browser-speech-artifacts.mjs

@@ -1962,6 +1962,10 @@ export function createDbopfsSpeechArtifactStore({
     return artifactGraphError(graphFileReason(descriptor, boundary), message);
   }
 
+  function reportArtifactProgress(onProgress, signal, progress) {
+      if (!signal?.aborted && is.function(onProgress)) onProgress(progress);
+  }
+
   async function openCached(authority, { signal, onProgress } = {}) {
     const graph = ARTIFACT_GRAPHS.has(authority);
     const metadata = artifactMetadata(authority);
@@ -1975,14 +1979,50 @@ export function createDbopfsSpeechArtifactStore({
     for (let index = 0; index < metadata.files.length; index += 1) {
       throwIfAborted(signal);
       const descriptor = metadata.files[index];
+      reportArtifactProgress(
+          onProgress,
+          signal,
+          {
+              phase: 'prepare',
+              stage: 'cache',
+              message: 'Opening cached speech file',
+              file: descriptor.path,
+              completed: index,
+              total: metadata.files.length,
+              unit: 'files',
+          }
+      );
       const file = await readFile(names.files[index]);
       if (!file) {
         await removeUnlocked(authority);
         return null;
       }
       files.push({ descriptor, file });
+      reportArtifactProgress(
+          onProgress,
+          signal,
+          {
+              phase: 'prepare',
+              stage: 'cache',
+              message: 'Opened cached speech file',
+              file: descriptor.path,
+              completed: files.length,
+              total: metadata.files.length,
+              unit: 'files',
+          }
+      );
     }
     try {
+      reportArtifactProgress(
+          onProgress,
+          signal,
+          {
+              phase: 'prepare',
+              stage: 'runtime',
+              message: 'Preparing speech runtime modules',
+              total: null,
+          }
+      );
       const routing = graph
         ? await planOrdinaryMaterializedRuntime({ files }, metadata, signal)
         : null;
@@ -2020,6 +2060,19 @@ export function createDbopfsSpeechArtifactStore({
         throwIfAborted(signal);
         const descriptor = metadata.files[index];
         const sourceUrl = graph ? descriptor.sourceUrl : descriptor.url;
+        reportArtifactProgress(
+            onProgress,
+            signal,
+            {
+                phase: 'download',
+                stage: 'artifacts',
+                message: 'Downloading speech file',
+                file: descriptor.path,
+                completed: index,
+                total: metadata.files.length,
+                unit: 'files',
+            }
+        );
         let response;
         try {
           response = await fetchFunction(sourceUrl, {
@@ -2095,7 +2148,30 @@ export function createDbopfsSpeechArtifactStore({
           throw speechError("ARCANE_AI_ARTIFACT_CACHE_REJECTED", "DBOPFS did not preserve a speech artifact.");
         }
         installed.push({ descriptor, file });
+        reportArtifactProgress(
+            onProgress,
+            signal,
+            {
+                phase: 'download',
+                stage: 'artifacts',
+                message: 'Stored speech file',
+                file: descriptor.path,
+                completed: installed.length,
+                total: metadata.files.length,
+                unit: 'files',
+            }
+        );
       }
+      reportArtifactProgress(
+          onProgress,
+          signal,
+          {
+              phase: 'prepare',
+              stage: 'runtime',
+              message: 'Preparing speech runtime modules',
+              total: null,
+          }
+      );
       const routing = graph
         ? await planOrdinaryMaterializedRuntime({ files: installed }, metadata, signal)
         : null;
@@ -2145,6 +2221,16 @@ export function createDbopfsSpeechArtifactStore({
       }
       throw speechError("ARCANE_AI_ARTIFACT_OFFLINE_MISS", "No cached offline speech artifacts are available.");
     }
+    reportArtifactProgress(
+        onProgress,
+        signal,
+        {
+            phase: 'prepare',
+            stage: 'runtime',
+            message: 'Opening prepared speech files',
+            total: null,
+        }
+    );
     if (graph) {
       const materialized = await createOrdinaryArtifactObjectUrls(
         admitted,

package/browser-runtime/ai/browser-speech-providers.mjs

@@ -621,6 +621,7 @@ function observeLoadOperation(record, { signal, progress }, role) {
       );
       return;
     }
+    if (record.lastProgress !== null) observer.progress(record.lastProgress);
   });
 }
 
@@ -1322,7 +1323,7 @@ function createBrowserSpeechProvider({
     return pool;
   }
 
-  async function loadWorkerPool(preparation, device, warnings, signal) {
+  async function loadWorkerPool(preparation, device, warnings, signal, onProgress) {
     const pool = createWorkerPool(preparation, device, warnings);
     const configuration = completeValue({
       role,
@@ -1336,15 +1337,46 @@ function createBrowserSpeechProvider({
     let failure = pool.failure;
     if (!failure) {
       try {
-        await pool.slots[0].client.request("load", { configuration }, { signal });
+        await pool.slots[0].client.request(
+            'load',
+            { configuration },
+            { signal, onProgress }
+        );
       } catch (error) {
         failure = error;
       }
     }
     if (!failure) {
       const remainingLoads = [];
+      let completedWorkers = 1;
+      function reportPoolProgress(detail) {
+          onProgress(
+              {
+                  phase: 'initialize',
+                  stage: 'workers',
+                  message: `Opening speech model sessions on ${device}`,
+                  completed: completedWorkers,
+                  total: pool.slots.length,
+                  unit: 'sessions',
+                  detail,
+              }
+          );
+      }
+      async function loadRemainingWorker(slot) {
+          await slot.client.request(
+              'load',
+              { configuration },
+              {
+                  signal,
+                  onProgress: reportPoolProgress,
+              }
+          );
+          completedWorkers += 1;
+          reportPoolProgress(null);
+      }
+      if (pool.slots.length > 1) reportPoolProgress(null);
       for (const slot of pool.slots.slice(1)) {
-        remainingLoads.push(slot.client.request("load", { configuration }, { signal }));
+        remainingLoads.push(loadRemainingWorker(slot));
       }
       const settlements = await Promise.allSettled(remainingLoads);
       failure = pool.failure;
@@ -1488,6 +1520,7 @@ function createBrowserSpeechProvider({
       errorCode = null;
       const record = {
         promise: null,
+        lastProgress: null,
         warnings: NO_PROVIDER_WARNINGS,
         observers: new Set(),
         settled: false,
@@ -1498,6 +1531,24 @@ function createBrowserSpeechProvider({
           linked.abort(reason, code);
         },
       };
+      const loadStartedAt = Date.now();
+      function reportLoadProgress(progress) {
+          if (
+              record.settled
+              || linked.controller.signal.aborted
+              || operationGeneration !== generation
+              || state !== 'loading'
+          ) return;
+          const value = {
+              ...progress,
+              elapsedMs: Math.max(
+                  0,
+                  Date.now() - loadStartedAt
+              ),
+          };
+          record.lastProgress = value;
+          for (const observer of [...record.observers]) observer.progress(value);
+      }
       lastWarnings = NO_PROVIDER_WARNINGS;
       selectedDevice = null;
       const promise = Promise.resolve().then(async function loadBrowserSpeechProviderPool() {
@@ -1505,10 +1556,22 @@ function createBrowserSpeechProvider({
         let preparation = null;
         let pool = null;
         try {
-          prepared = await store.prepare(authority.graph ?? authority, {
-            signal: linked.controller.signal,
-            offline,
-          });
+          reportLoadProgress(
+              {
+                  phase: 'prepare',
+                  stage: 'cache',
+                  message: 'Opening stored speech runtime files',
+                  total: null,
+              }
+          );
+          prepared = await store.prepare(
+              authority.graph ?? authority,
+              {
+                  signal: linked.controller.signal,
+                  offline,
+                  onProgress: reportLoadProgress,
+              }
+          );
           preparation = {
             prepared,
             released: false,
@@ -1548,6 +1611,7 @@ function createBrowserSpeechProvider({
                 device,
                 record.warnings,
                 linked.controller.signal,
+                reportLoadProgress,
               );
               break;
             } catch (error) {

package/browser-runtime/ai/browser-wasm-llm-provider.mjs

@@ -8,7 +8,7 @@ import {
   resolveModelSecurity,
 } from "./model-controller.mjs";
 import { createPackagedWllamaRuntime } from "./browser-wllama-runtime.mjs";
-import { getBrowserDeviceSettings, openBrowserDeviceSettings } from "./browser-device-settings.mjs";
+import { getBrowserDeviceSettings, describeBrowserGpu } from "./browser-device-settings.mjs";
 import { arcaneEvents } from "../event-manager.mjs";
 
 const is = new Is(false);
@@ -269,21 +269,22 @@ function notifyHighPerformanceGpu(adapter) {
     if (highPerformanceGpuNoticeShown) {
         return;
     }
+    const selection = describeBrowserGpu(adapter);
+    if (selection.performanceStatus !== "integrated" && selection.performanceStatus !== "fallback") {
+        return;
+    }
     const browser = getBrowserDeviceSettings().highPerformanceGpu;
     if (!browser) {
         return;
     }
     highPerformanceGpuNoticeShown = true;
-    const adapterName = adapter.description || adapter.name
-        || [adapter.vendor, adapter.architecture].filter(Boolean).join(" ")
-        || "the available WebGPU adapter";
-    openBrowserDeviceSettings(
-        browser,
-        `Selected WebGPU adapter: ${adapterName}.\n\n`
-        + `If this computer has multiple GPUs, enable “Force High Performance GPU” in ${browser.name} `
-        + "to request the high-performance GPU when available. "
-        + `Then completely close and reopen ${browser.name} before loading the model again.\n\n`
-        + `If the flags page did not open, paste ${browser.url} into the address bar.`,
+    const selectedKind = selection.performanceStatus === "fallback" ? "Software/fallback" : "Integrated";
+    globalThis.alert?.(
+        `${selectedKind} WebGPU adapter selected: ${selection.name}.\n\n`
+        + "If this computer also has a discrete GPU, the browser may be able to use it. "
+        + `Copy ${browser.url} into the address bar in ${browser.name} `
+        + "and enable “Force High Performance GPU” to request it when available. "
+        + `Save your work, then completely close and reopen ${browser.name} before loading the model again.`,
     );
 }
 
@@ -3057,7 +3058,9 @@ export function createBrowserWasmLlmProvider({
             "Wllama did not confirm that the model loaded successfully.",
           );
         }
-        emitWebgpuAdapterSelection(activeSource, runtime);
+        if (!signal?.aborted && generation === lifecycleGeneration && state === 'loading') {
+            emitWebgpuAdapterSelection(activeSource, runtime);
+        }
         throwIfAborted(signal, "load");
         if (generation !== lifecycleGeneration || state !== "loading") {
           await runtime.exit();

package/browser-runtime/ai/browser-wllama-runtime.mjs

@@ -1,6 +1,6 @@
 import Is from "../dependencies/strong-type/index.js";
 import { arcaneLogging } from '../logging.mjs';
-import { Wllama } from "./wllama/index.mjs";
+import {Wllama, WllamaRuntimeError} from './wllama/index.mjs';
 
 const is = new Is(false);
 
@@ -567,7 +567,46 @@ export function createPackagedWllamaRuntime({ logger = arcaneLogging } = {}) {
           "Wllama did not confirm a successfully loaded model.",
         );
       }
-      const webgpu = { observed: true, apiPresent: true };
+      let adapter = null;
+      const telemetryOperation = trackOperation(
+          Promise.resolve().then(
+              function observeLoadedGpu() {
+                  return next.arcaneTelemetry();
+              }
+          )
+      );
+      function cancelGpuObservation() {
+          telemetryOperation.cancel(loadController.signal.reason);
+      }
+      loadController.signal.addEventListener(
+          'abort',
+          cancelGpuObservation,
+          {once: true}
+      );
+      if (loadController.signal.aborted) cancelGpuObservation();
+      try {
+          // Observe the adapter this loaded Worker already selected; do not probe
+          // a second adapter in the page and attribute it to the model.
+          const telemetry = await telemetryOperation.result;
+          if (telemetry?.worker?.invalid === true) {
+              arcaneLogging.warn("The loaded model's GPU adapter observation is inconsistent.", telemetry.worker);
+          } else {
+              adapter = telemetry?.worker?.adapter ?? null;
+          }
+      } catch (error) {
+          if (loadController.signal.aborted || error instanceof WllamaRuntimeError) throw error;
+          arcaneLogging.warn("The loaded model's GPU adapter details are unavailable.", error);
+      } finally {
+          loadController.signal.removeEventListener('abort', cancelGpuObservation);
+      }
+      if (progressFailure) throw progressFailure;
+      if (loadController.signal.aborted) throw cancellationError(loadController.signal.reason);
+      if (pending?.engine !== next) throw new Error('Wllama load was cancelled.');
+      const webgpu = {
+          observed: true,
+          apiPresent: true,
+          adapter
+      };
       pending = null;
       engine = next;
       publishEvidence({ state: "ready", webgpu, cancellation: null, cleanup: null });

package/browser-runtime/ai/speech-worker-client.mjs

@@ -166,6 +166,11 @@ class SpeechWorkerClient {
       ), { intentional: false }).catch(() => undefined);
       return;
     }
+    if (is.safeInteger(message.id) && message.type === 'progress') {
+        const pending = this.#pending.get(message.id);
+        if (pending?.op === 'load') pending.onProgress?.(message.progress);
+        return;
+    }
     if (!is.safeInteger(message.id) || !is.boolean(message.ok)) {
       void this.terminate(clientError(
         "ARCANE_AI_WORKER_MESSAGE_ERROR",
@@ -207,7 +212,7 @@ class SpeechWorkerClient {
     ));
   }
 
-  request(op, payload, { signal = null } = {}) {
+  request(op, payload, { signal = null, onProgress = null } = {}) {
     this.#trace("request.call", { op, payload, aborted: signal?.aborted });
     if (!PUBLIC_WORKER_OPERATIONS.has(op)) {
       this.#trace("request.rejected", { op, reason: "unknown-operation" });
@@ -283,7 +288,10 @@ class SpeechWorkerClient {
         });
       }
       signal?.addEventListener?.("abort", onAbort, { once: true });
-      client.#pending.set(id, { resolve, reject, cleanup, op });
+      client.#pending.set(
+          id,
+          { resolve, reject, cleanup, op, onProgress }
+      );
       const message = {
         protocol: SPEECH_WORKER_PROTOCOL,
         id,