arcane-os 0.5.18 → 0.5.19

package/CHANGELOG.md

@@ -1,6 +1,17 @@
 # Changelog
 
-## Unreleased
+## 0.5.19
+
+- Report observed Wllama initialization stages and runtime activity through
+  direct provider loading and the shared AI lifecycle. Keep initialization
+  indeterminate when the runtime supplies no meaningful completion total.
+- Show the current initialization stage, stage duration, and time since runtime
+  activity in shared chat instead of a completed file count during activation.
+  Preserve download progress, cancellation, and complete runtime logging.
+- Remove an adjacent duplicate cancellation check while retaining cancellation
+  handling before initialization and after loading.
+
+## 0.5.18
 
 - Use `strong-type` predicates throughout SDK-owned toolchain, runtime,
   browser-provider, and component code while retaining existing defaults,
@@ -12,8 +23,6 @@
 - Remove `AIResponseLength` exports; applications own response verbosity.
   Parse URL-audit HTML with the native HTML parser.
 
-## 0.5.18
-
 - Add `AI.prepareTTS()` for detached punctuation-segmented synthesis, optional
   DBOPFS audio storage, complete semantic-input reuse, shared pending work and
   independent preparation cancellation. Persist MIME metadata with each audio

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.5.18` SDK contract. Applications pin one exact npm
+This checkout defines the `0.5.19` 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.5.18 new hello-speech --path ./hello-speech --target browser
+npx arcane-os@0.5.19 new hello-speech --path ./hello-speech --target browser
 cd hello-speech
 npm install
 npm run dev
@@ -357,7 +357,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.5.18 new my-app --path ./my-app --target portable --git
+npx arcane-os@0.5.19 new my-app --path ./my-app --target portable --git
 cd my-app
 npm install
 npm run dev
@@ -367,7 +367,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.5.18
+npm install --save-dev --save-exact arcane-os@0.5.19
 npm exec -- arcane init my-app --target portable
 ```
 
@@ -383,7 +383,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.5.18` for the initial bootstrap because it names this npm
+Use `npx arcane-os@0.5.19` 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`,
@@ -403,7 +403,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.5.18.tgz
+npm install --save-dev --save-exact ../arcane-os-sdk/arcane-os-0.5.19.tgz
 npm ci
 ```
 
@@ -412,7 +412,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.5.18` registry package and
+the local declaration with the exact `arcane-os@0.5.19` registry package and
 commit the regenerated lock.
 
 Generated repositories use `npm ci --ignore-scripts` in CI. Run dependency
@@ -551,7 +551,7 @@ package installation, or assertions.
 
 ## Current target support
 
-Version `0.5.18` exposes one browser target and five explicitly paired
+Version `0.5.19` 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-wasm-llm-provider.mjs

@@ -3000,24 +3000,47 @@ export function createBrowserWasmLlmProvider({
       ? context.reportProgress
       : options.onProgress ?? null;
     const progressStartedAt = Date.now();
+    let progressStageStartedAt = progressStartedAt;
+    let progressUpdatedAt = progressStartedAt;
     let currentProgress = null;
     let progressHeartbeat = null;
 
     function publishModelLoadProgress(progress) {
-      if (!reportProgress) return;
+      if (!reportProgress || signal.aborted || generation !== lifecycleGeneration || state !== "loading") return;
+      const now = Date.now();
+      if (currentProgress?.phase !== progress.phase || currentProgress?.stage !== progress.stage) {
+        progressStageStartedAt = now;
+      }
+      progressUpdatedAt = now;
       currentProgress = { ...progress, heartbeat: false };
       reportProgress(completeValue({
         ...currentProgress,
-        elapsedMs: Math.max(0, Date.now() - progressStartedAt),
+        elapsedMs: Math.max(0, now - progressStartedAt),
+        ...(progress.phase === "initialize" ? {
+          phaseElapsedMs: Math.max(0, now - progressStageStartedAt),
+          activityElapsedMs: 0,
+        } : {}),
       }));
     }
 
+    function publishModelInitializationProgress(progress) {
+      if (!reportProgress || signal.aborted || generation !== lifecycleGeneration || state !== "loading") return;
+      progressUpdatedAt = Date.now();
+      if (!progress || (currentProgress?.stage === progress.stage && currentProgress?.message === progress.message)) return;
+      publishModelLoadProgress(progress);
+    }
+
     function publishModelLoadHeartbeat() {
-      if (!reportProgress || !currentProgress) return;
+      if (!reportProgress || !currentProgress || signal.aborted || generation !== lifecycleGeneration || state !== "loading") return;
+      const now = Date.now();
       reportProgress(completeValue({
         ...currentProgress,
         heartbeat: true,
-        elapsedMs: Math.max(0, Date.now() - progressStartedAt),
+        elapsedMs: Math.max(0, now - progressStartedAt),
+        ...(currentProgress.phase === "initialize" ? {
+          phaseElapsedMs: Math.max(0, now - progressStageStartedAt),
+          activityElapsedMs: Math.max(0, now - progressUpdatedAt),
+        } : {}),
       }));
     }
 
@@ -3047,16 +3070,12 @@ export function createBrowserWasmLlmProvider({
         if (generation !== lifecycleGeneration || state !== "loading") {
           throw fail("ARCANE_AI_OPERATION_SUPERSEDED", "The model load was superseded by unload.");
         }
-        throwIfAborted(signal, "load");
-        if (generation !== lifecycleGeneration || state !== "loading") {
-          throw fail("ARCANE_AI_OPERATION_SUPERSEDED", "The model load was superseded by unload.");
-        }
         const members = sourceMetadata(activeSource).files;
         publishModelLoadProgress({
           phase: "initialize",
-          completed: members.length,
-          total: members.length,
-          unit: "files",
+          stage: "runtime",
+          message: "Starting the WebAssembly runtime and opening model files",
+          total: null,
           heartbeat: false,
         });
         const modelFiles = admitted.files.map((file, index) => (
@@ -3074,6 +3093,7 @@ export function createBrowserWasmLlmProvider({
           ...runtimeOptions,
           ...activeLoadPlan,
           signal,
+          onProgress: publishModelInitializationProgress,
         });
         if (!runtime.isLoaded()) {
           throw fail(

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

@@ -94,6 +94,59 @@ function createEvidenceLogger(logger) {
   let offload = null;
   let invalid = false;
   let completionCapture = null;
+  let loadProgress = null;
+  let tensorCount = null;
+
+  function observeLoadLine(line) {
+    if (!loadProgress) return;
+    let stage;
+    let message;
+    const metadata = line.match(/^llama_model_loader: loaded meta data with \d+ key-value pairs and (\d+) tensors from /u);
+    const layers = line.match(GPU_OFFLOAD_PATTERN);
+    if (line.startsWith('Loading "wllama.wasm" from ')) {
+      stage = "runtime";
+      message = "Loading the WebAssembly runtime";
+    } else if (line === "Calling wllamaStart...") {
+      stage = "backend";
+      message = "Starting the inference engine";
+    } else if (line === "Loading model...") {
+      stage = "metadata";
+      message = "Reading model metadata";
+    } else if (WEBGPU_ADAPTER_PATTERN.test(line)) {
+      stage = "gpu";
+      message = "Graphics device initialized; preparing the model";
+    } else if (metadata) {
+      tensorCount = Number(metadata[1]);
+      stage = "metadata";
+      message = `Model metadata read: ${tensorCount} tensors`;
+    } else if (line.startsWith("load_tensors: loading model tensors,")) {
+      stage = "weights";
+      message = tensorCount === null
+        ? "Loading model weights"
+        : `Loading model weights for ${tensorCount} tensors`;
+    } else if (layers) {
+      // Upstream reports layer assignment before the weight reads finish.
+      stage = "weights";
+      message = `Loading model weights; ${layers[1]} of ${layers[2]} layers assigned to the GPU`;
+    } else if (line === "llama_context: constructing llama_context") {
+      stage = "context";
+      message = "Preparing the inference context";
+    } else if (/^[^:]+:\s+graph (?:nodes|splits)\s+=\s+\d+/u.test(line)) {
+      stage = "graph";
+      message = "Preparing the inference graph";
+    } else if (/^cmn\s+common_init_:\s+warming up the model with an empty run\b/u.test(line)) {
+      stage = "warmup";
+      message = "Warming up the model with an empty run";
+    }
+    if (stage) {
+      loadProgress({
+        phase: "initialize",
+        stage,
+        message,
+        total: null,
+      });
+    }
+  }
 
   function same(left, right) {
     return JSON.stringify(left) === JSON.stringify(right);
@@ -119,6 +172,7 @@ function createEvidenceLogger(logger) {
     observeCompletionLine(level, value);
     const line = String(value).trim();
     if (!line) return;
+    observeLoadLine(line);
     const adapterMatch = line.match(WEBGPU_ADAPTER_PATTERN);
     if (adapterMatch) {
       const next = completeValue({
@@ -144,6 +198,8 @@ function createEvidenceLogger(logger) {
   }
 
   function observe(level, args) {
+    // Activity without a new stage updates its age without repainting the UI.
+    loadProgress?.(null);
     for (const value of args) {
       if (!is.string(value)) continue;
       for (const line of value.split(/\r?\n/u)) observeLine(level, line);
@@ -160,6 +216,13 @@ function createEvidenceLogger(logger) {
 
   return completeValue({
     logger: completeValue(wrapped),
+    beginLoadProgress(report) {
+      loadProgress = report;
+      tensorCount = null;
+      return function releaseLoadProgress() {
+        loadProgress = null;
+      };
+    },
     beginCompletionCapture() {
       if (completionCapture) {
         throw runtimeFailure(
@@ -469,6 +532,18 @@ export function createPackagedWllamaRuntime({ logger = arcaneLogging } = {}) {
       cleanup: null,
     });
     const loadController = new AbortController();
+    let progressFailure = null;
+    const releaseLoadProgress = sessionObservers.get(next).beginLoadProgress(
+      function reportRuntimeLoadProgress(progress) {
+        if (loadController.signal.aborted || !is.function(options.onProgress)) return;
+        try {
+          options.onProgress(progress);
+        } catch (error) {
+          progressFailure = error;
+          loadController.abort(error);
+        }
+      },
+    );
     const loadOperation = Promise.resolve().then(() => (
       next.arcaneLoadModel(files, loadOptions, loadController.signal)
     ));
@@ -484,6 +559,7 @@ export function createPackagedWllamaRuntime({ logger = arcaneLogging } = {}) {
     else signal?.addEventListener?.("abort", onAbort, { once: true });
     try {
       await loadOperation;
+      if (progressFailure) throw progressFailure;
       if (pending?.engine !== next) throw new Error("Wllama load was cancelled.");
       if (!is.function(next.isModelLoaded) || next.isModelLoaded() !== true) {
         throw runtimeFailure(
@@ -496,6 +572,7 @@ export function createPackagedWllamaRuntime({ logger = arcaneLogging } = {}) {
       engine = next;
       publishEvidence({ state: "ready", webgpu, cancellation: null, cleanup: null });
     } catch (error) {
+      releaseLoadProgress();
       let cleanupFailure = null;
       try {
         await exitSession(next);
@@ -513,6 +590,7 @@ export function createPackagedWllamaRuntime({ logger = arcaneLogging } = {}) {
       if (cleanupFailure) throw cleanupFailure;
       throw error;
     } finally {
+      releaseLoadProgress();
       signal?.removeEventListener?.("abort", onAbort);
     }
 

package/docs/architecture.md

@@ -279,7 +279,7 @@ paths are withheld from the native provider. The provider copies the complete
 selected release rather than accepting an unrelated source path. Verification
 is a separate explicit operation for a selected release artifact.
 
-The SDK `0.5.17` runtime requires Arcane `0.8.12` or newer. Compatibility
+The SDK `0.5.19` runtime requires Arcane `0.8.12` or newer. Compatibility
 is contractual rather than exact-version pinning: the prepared Core must meet
 the highest minimum declared by the runtime, selected app, and bundled app
 dependencies; keep each app's Arcane protocol generation; and provide every

package/docs/publishing.md

@@ -16,7 +16,13 @@ dependency and invoke its local CLI with `npm exec -- arcane`. A separate
 global installer, standalone SDK executable, NuGet package, Homebrew formula,
 or OS package is not part of this release surface.
 
-Publication checks run only after the user explicitly selects an npm release.
+The user's standing instruction selects publication when a coherent SDK change
+is complete. Publish every ready change that preserves required functionality
+and remains relevant, while excluding unfinished concurrent or explicitly
+deferred work. Default to a patch release and assess whether a new capability
+warrants a minor revision. Honor an explicit no-publish instruction.
+
+Publication checks run only for that selected npm release output.
 That selected-release workflow validates package metadata, the executable and
 `.gitattributes` boundary, the complete package inventory, version/channel
 agreement, and required license notices. One unprivileged producer packs one
@@ -94,9 +100,9 @@ locked installation, runs one selected `arcane package`, creates one selected
 identities, receipts, provenance records, or attestation sidecars and does not
 run a second admission job.
 
-Stable versioning, the npm `latest` tag, and an official GitHub release remain a
-separate explicit release decision. Current `main` development does not
-silently convert a `-dev` package into an official release. A stable release
+Stable versioning, the npm `latest` tag, and an official GitHub release follow
+the selected release decision, including the standing completed-work authority
+above. Unfinished `main` development does not select a release. A stable release
 must publish the exact selected Check artifact under `latest`; GitHub may then
 attach that same package. Its Git
 tag and GitHub release title must both be the same bare numeric

package/docs/reference/ai/browser-wasm.md

@@ -101,10 +101,31 @@ active-worker count changes, and the download completes. At known completion, re
 and active transfers are zero. Applications format the raw measures into B,
 KB, MB, GB, transfer-rate, and duration labels.
 
-While a load remains active, the provider also repeats its current record every
-five seconds with `heartbeat:true` and an updated `elapsedMs`. A heartbeat
-confirms that the owned operation is still active; it does not invent
-additional transferred content.
+Initialization keeps `phase:'initialize'` and reports a `stage` and a readable
+`message` from the packaged runtime's existing log signals: runtime startup,
+engine startup, model metadata, graphics-device initialization, model weights,
+inference context, and inference graph. Warmup is shown only if the runtime
+actually reports it; the default upstream log level may omit that signal.
+These messages do not change the runtime's log level or replace its complete
+diagnostic output.
+
+Initialization has `total:null` and omits `completed` and `unit`, so its progress
+bar is indeterminate. Downloaded-file completion is not activation completion.
+The metadata tensor count and GPU layer assignment are descriptive only:
+upstream reports assigned layers before model-weight loading has finished.
+The pinned runtime does not expose a measured overall initialization fraction
+or a shader-compilation completion count. Readiness still requires the load
+operation to resolve and the runtime to confirm the model is loaded.
+
+While a load remains active, the provider repeats its current record every five
+seconds with `heartbeat:true` and an updated `elapsedMs`. During initialization,
+`phaseElapsedMs` measures time in the current stage and `activityElapsedMs`
+measures time since the most recent runtime log signal. A signal without a
+recognized stage updates activity time without triggering another UI render.
+The shared chat loading panel shows the observed stage and those timings. A
+heartbeat only shows that the provider's timer ran; it does not establish
+runtime advancement, estimate a completion time, or advance the progress bar.
+Late runtime progress is ignored after cancellation or supersession.
 
 The DBOPFS store uses one bounded transfer axis. Ordered multi-file GGUF sets
 download several members concurrently and preserve completed shards across a
@@ -470,8 +491,10 @@ identity, default model metadata,
 `streamChat`, `use`, `probe`, and `dispose`. Direct provider `load()` selects a
 catalog model and returns `{model,status}`;
 the public AI API module's `ai.load()` returns the flat controller status.
-Direct `load({onProgress})` forwards the same additive file and byte progress
-records used by the controller and provider/2 adapter.
+Direct `load({onProgress})` forwards the same download progress and observed
+initialization-stage/activity records used by the controller and provider/2
+adapter. Initialization has no completion percentage unless the runtime reports
+a meaningful completion total.
 Provider `security` carries the provider/model-binding `secure` intent. Direct
 `provider.load({security})` and `ai.load({security})` supply the operation
 intent. They do not activate checking in the ordinary development contract.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arcane-os",
-  "version": "0.5.18",
+  "version": "0.5.19",
   "description": "Arcane OS JavaScript SDK, project-local CLI, browser runtime, and repository-portable application packager.",
   "type": "module",
   "main": "./src/index.mjs",

package/runtime/arcane/components/chat.html

@@ -2039,6 +2039,20 @@
         }
 
         function determinateProgress(){
+            if(role?.progress?.phase==='initialize'){
+                const {completed,total,unit}=role.progress;
+                if(
+                    !is.finite(total)
+                    ||total<=0
+                    ||!is.finite(completed)
+                    ||completed<0
+                    ||!is.string(unit)
+                    ||!unit
+                ){
+                    return null;
+                }
+                return {completed,total,unit,byteTelemetry:false};
+            }
             const totalBytes=role?.progress?.totalBytes;
             const loadedBytes=role?.progress?.loadedBytes;
             if(
@@ -2160,8 +2174,10 @@
             return `${active} of ${limit} ${noun}${limit===1?'':'s'} active`;
         }
 
-        function progressElapsedText(){
-            const elapsedMilliseconds=Number(role?.progress?.elapsedMs);
+        function progressElapsedText(
+            elapsedMilliseconds,
+            suffix='elapsed'
+        ){
             if(!is.finite(elapsedMilliseconds)||elapsedMilliseconds<0){
                 return '';
             }
@@ -2170,12 +2186,12 @@
             const minutes=Math.floor(elapsedSeconds%3600/60);
             const seconds=elapsedSeconds%60;
             if(hours>0){
-                return `${hours}h ${minutes}m elapsed`;
+                return `${hours}h ${minutes}m ${suffix}`;
             }
             if(minutes>0){
-                return `${minutes}m ${String(seconds).padStart(2,'0')}s elapsed`;
+                return `${minutes}m ${String(seconds).padStart(2,'0')}s ${suffix}`;
             }
-            return `${seconds}s elapsed`;
+            return `${seconds}s ${suffix}`;
         }
 
         function progressMessage(){
@@ -2183,7 +2199,14 @@
             const phaseValue=is.string(role?.progress?.phase)&&role.progress.phase
                 ?role.progress.phase
                 :'loading';
-            const phase=phaseValue.replaceAll('-',' ');
+            const initializing=phaseValue==='initialize';
+            const phase=initializing
+                ?is.string(role?.progress?.message)&&role.progress.message
+                    ?role.progress.message
+                    :is.string(role?.progress?.stage)&&role.progress.stage
+                        ?role.progress.stage.replaceAll('-',' ')
+                        :'Initializing the selected model'
+                :phaseValue.replaceAll('-',' ');
             const parts=[
                 `Loading ${modelDisplayName()} through the Arcane SDK`,
                 phase
@@ -2211,18 +2234,38 @@
                     :measured.unit;
                 parts.push(`${measured.completed} of ${measured.total} ${suffix}`);
             }
-            const transfers=activeTransferText();
+            const transfers=initializing?'':activeTransferText();
             if(transfers){
                 parts.push(transfers);
             }
-            const elapsed=progressElapsedText();
+            const elapsed=progressElapsedText(Number(role?.progress?.elapsedMs));
             if(elapsed){
                 parts.push(elapsed);
-                if(role?.progress?.heartbeat===true){
+                if(!initializing&&role?.progress?.heartbeat===true){
                     parts.push('Still working');
                 }
             }
-            if(!measured?.byteTelemetry){
+            if(initializing){
+                const phaseElapsed=progressElapsedText(
+                    role.progress.phaseElapsedMs,
+                    'in this stage'
+                );
+                if(phaseElapsed){
+                    parts.push(phaseElapsed);
+                }
+                if(role.progress.heartbeat===true){
+                    const activityElapsed=progressElapsedText(
+                        role.progress.activityElapsedMs,
+                        'ago'
+                    );
+                    if(activityElapsed){
+                        parts.push(`Last runtime activity ${activityElapsed}`);
+                    }
+                }
+                parts.push(measured
+                    ?'Keep this tab open'
+                    :'Completion percentage unavailable; keep this tab open');
+            }else if(!measured?.byteTelemetry){
                 parts.push('The first activation can take several minutes; keep this tab open');
             }
             return parts.join(' · ');