arcane-os 0.5.18 → 0.6.0

package/CHANGELOG.md

@@ -1,6 +1,32 @@
 # Changelog
 
-## Unreleased
+## 0.6.0
+
+- Prefer WebNN NPU, then WebGPU, then CPU through WASM for browser Whisper
+  transcription and Kokoro synthesis. Skip absent accelerator APIs and replace
+  failed model-load Workers before trying the next backend with the same
+  application-selected model and precision.
+- Add Whisper execution configuration and NPU selection for both speech roles.
+  Explicit `webnn-npu`, `webgpu`, and `wasm` choices report failure without
+  falling back. Whisper retains one slot; Kokoro retains four by default and
+  accepts capacities from one through four.
+- Report requested and successfully selected backends for both roles through
+  provider execution status. Selection reports upstream session loading;
+  actual accelerator use and speech quality depend on the selected runtime,
+  model, browser, drivers, and hardware. Wllama remains on its WebGPU backend.
+
+## 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 +38,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.6.0` 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.6.0 new hello-speech --path ./hello-speech --target browser
 cd hello-speech
 npm install
 npm run dev
@@ -299,10 +299,16 @@ provider factories. The package contains the plain-JavaScript provider and
 Worker machinery, not speech runtimes, models, voices, or a CDN default. An app
 must supply each runtime/model selection explicitly. Speech roles
 load, cancel, unload, fail, and recover independently, so speech failure never
-silently falls back or prevents text chat. Kokoro defaults to a four-slot Worker
-and model-session pool: it selects WebGPU when the browser can load the complete
-pool and otherwise recreates that pool on WASM. Apps may select `webgpu` or
-`wasm` explicitly and may set the bounded TTS capacity from one through four.
+switches to a cloud provider or prevents text chat. Both roles default to
+NPU, GPU, then CPU automatic selection: WebNN NPU when its browser API is
+exposed, then WebGPU, then WASM. Failed model loads release their Workers before
+the next backend uses the same model and precision. Apps may select
+`webnn-npu`, `webgpu`, or `wasm` explicitly without automatic fallback.
+Whisper keeps one transcription slot; Kokoro defaults to four Worker/model
+sessions and accepts capacities from one through four. Both roles expose
+requested and selected devices through execution status. A selected backend
+reports successful upstream loading, not physical accelerator use for every
+operation; model and hardware compatibility remain upstream.
 
 Applications that need faster spoken-response onset can configure the shared
 TTS stream without taking over synthesis or playback:
@@ -357,7 +363,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.6.0 new my-app --path ./my-app --target portable --git
 cd my-app
 npm install
 npm run dev
@@ -367,7 +373,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.6.0
 npm exec -- arcane init my-app --target portable
 ```
 
@@ -383,7 +389,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.6.0` 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 +409,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.6.0.tgz
 npm ci
 ```
 
@@ -412,7 +418,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.6.0` registry package and
 commit the regenerated lock.
 
 Generated repositories use `npm ci --ignore-scripts` in CI. Run dependency
@@ -551,7 +557,7 @@ package installation, or assertions.
 
 ## Current target support
 
-Version `0.5.18` exposes one browser target and five explicitly paired
+Version `0.6.0` 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-speech-providers.mjs

@@ -23,8 +23,8 @@ const ROLE_OPERATION = completeValue({ stt: "transcribe", tts: "synthesize" });
 const STT_SAMPLE_RATE = 16_000;
 const TTS_SAMPLE_RATE = 24_000;
 const TTS_RESPONSE_FORMAT = "wav";
-const TTS_EXECUTION_DEVICES = new Set(["auto", "webgpu", "wasm"]);
-const DEFAULT_TTS_EXECUTION_DEVICE = "auto";
+const SPEECH_EXECUTION_DEVICES = new Set(["auto", "webnn-npu", "webgpu", "wasm"]);
+const DEFAULT_SPEECH_EXECUTION_DEVICE = "auto";
 const DEFAULT_TTS_MAX_CONCURRENT_REQUESTS = 4;
 const MAX_TTS_CONCURRENT_REQUESTS = 4;
 const ROLE_REQUEST_REASON = completeValue({
@@ -150,24 +150,21 @@ function requiredIdentifier(value, label) {
 }
 
 function normalizeSpeechExecution(role, execution) {
-  if (role === "stt") {
-    if (execution !== undefined) {
-      throw new TypeError("Browser Whisper does not accept an execution option.");
-    }
-    return completeValue({ device: "wasm", maxConcurrentRequests: 1 });
-  }
+  const label = role === "stt" ? "Browser Whisper" : "Browser Kokoro";
+  const defaultConcurrency = role === "stt" ? 1 : DEFAULT_TTS_MAX_CONCURRENT_REQUESTS;
+  const maximumConcurrency = role === "stt" ? 1 : MAX_TTS_CONCURRENT_REQUESTS;
   if (execution === undefined) {
     return completeValue({
-      device: DEFAULT_TTS_EXECUTION_DEVICE,
-      maxConcurrentRequests: DEFAULT_TTS_MAX_CONCURRENT_REQUESTS,
+      device: DEFAULT_SPEECH_EXECUTION_DEVICE,
+      maxConcurrentRequests: defaultConcurrency,
     });
   }
   if (!execution || !is.object(execution) || is.array(execution)) {
-    throw new TypeError("Browser Kokoro execution must be a plain data record.");
+    throw new TypeError(`${label} execution must be a plain data record.`);
   }
   const prototype = Object.getPrototypeOf(execution);
   if (prototype !== Object.prototype && prototype !== null) {
-    throw new TypeError("Browser Kokoro execution must be a plain data record.");
+    throw new TypeError(`${label} execution must be a plain data record.`);
   }
   const descriptors = Object.getOwnPropertyDescriptors(execution);
   for (const key of Reflect.ownKeys(descriptors)) {
@@ -175,34 +172,35 @@ function normalizeSpeechExecution(role, execution) {
       (key !== "device" && key !== "maxConcurrentRequests")
       || !Object.hasOwn(descriptors[key], "value")
     ) {
-      throw new TypeError("Browser Kokoro execution contains an unsupported or accessor field.");
+      throw new TypeError(`${label} execution contains an unsupported or accessor field.`);
     }
   }
   const device = Object.hasOwn(descriptors, "device")
     ? descriptors.device.value
-    : DEFAULT_TTS_EXECUTION_DEVICE;
+    : DEFAULT_SPEECH_EXECUTION_DEVICE;
   const maxConcurrentRequests = Object.hasOwn(descriptors, "maxConcurrentRequests")
     ? descriptors.maxConcurrentRequests.value
-    : DEFAULT_TTS_MAX_CONCURRENT_REQUESTS;
-  if (!TTS_EXECUTION_DEVICES.has(device)) {
-    throw new TypeError('Browser Kokoro execution.device must be "auto", "webgpu", or "wasm".');
+    : defaultConcurrency;
+  if (!SPEECH_EXECUTION_DEVICES.has(device)) {
+    throw new TypeError(`${label} execution.device must be "auto", "webnn-npu", "webgpu", or "wasm".`);
   }
   if (
     !is.safeInteger(maxConcurrentRequests)
     || maxConcurrentRequests < 1
-    || maxConcurrentRequests > MAX_TTS_CONCURRENT_REQUESTS
+    || maxConcurrentRequests > maximumConcurrency
   ) {
-    throw new TypeError("Browser Kokoro execution.maxConcurrentRequests must be a safe integer from 1 through 4.");
+    throw new TypeError(`${label} execution.maxConcurrentRequests must be a safe integer from 1 through ${maximumConcurrency}.`);
   }
   return completeValue({ device, maxConcurrentRequests });
 }
 
-function navigatorHasWebGpu() {
-  try {
-    return Boolean(globalThis.navigator?.gpu);
-  } catch {
-    return false;
-  }
+function speechExecutionDevices(requestedDevice) {
+  if (requestedDevice !== "auto") return [requestedDevice];
+  const devices = [];
+  if (is.function(globalThis.navigator?.ml?.createContext)) devices.push("webnn-npu");
+  if (globalThis.navigator?.gpu) devices.push("webgpu");
+  devices.push("wasm");
+  return devices;
 }
 
 function createProviderAuthority({
@@ -1187,14 +1185,12 @@ function createBrowserSpeechProvider({
       cache,
       lifecycleReason,
       activeOperation,
-      execution: role === "tts"
-        ? completeValue({
-          requestedDevice: speechExecution.device,
-          selectedDevice,
-          maxConcurrentRequests: speechExecution.maxConcurrentRequests,
-          activeRequestCount: requestOperations.size,
-        })
-        : null,
+      execution: completeValue({
+        requestedDevice: speechExecution.device,
+        selectedDevice,
+        maxConcurrentRequests: speechExecution.maxConcurrentRequests,
+        activeRequestCount: requestOperations.size,
+      }),
       secureIntent,
       warnings: providerWarnings(runtimeWarnings),
     });
@@ -1535,34 +1531,42 @@ function createBrowserSpeechProvider({
               `${role}-load-superseded-by-unload`,
             );
           }
-          const primaryDevice = role === "stt"
-            ? "wasm"
-            : speechExecution.device === "auto"
-              ? navigatorHasWebGpu() ? "webgpu" : "wasm"
-              : speechExecution.device;
-          try {
-            pool = await loadWorkerPool(
-              preparation,
-              primaryDevice,
-              record.warnings,
-              linked.controller.signal,
-            );
-          } catch (error) {
-            if (
-              role !== "tts"
-              || speechExecution.device !== "auto"
-              || primaryDevice !== "webgpu"
-              || linked.controller.signal.aborted
-              || operationGeneration !== generation
-            ) {
-              throw error;
+          const devices = speechExecutionDevices(speechExecution.device);
+          for (const [index, device] of devices.entries()) {
+            throwIfAborted(linked.controller.signal, `${role}-load-cancelled`);
+            if (operationGeneration !== generation) {
+              throw providerError(
+                "ARCANE_AI_OPERATION_SUPERSEDED",
+                "Browser speech loading was superseded.",
+                undefined,
+                `${role}-load-superseded-by-unload`,
+              );
+            }
+            try {
+              pool = await loadWorkerPool(
+                preparation,
+                device,
+                record.warnings,
+                linked.controller.signal,
+              );
+              break;
+            } catch (error) {
+              if (
+                index === devices.length - 1
+                || linked.controller.signal.aborted
+                || operationGeneration !== generation
+                || error?.code === "ARCANE_AI_REQUEST_ABORTED"
+                || error?.code === "ARCANE_AI_OPERATION_SUPERSEDED"
+              ) {
+                throw error;
+              }
+              // A fresh Worker releases a failed upstream initialization before
+              // the next backend reuses the same prepared model and precision.
+              const warning = `Browser ${role} ${device} loading failed; trying ${devices[index + 1]}.`;
+              record.warnings = [...record.warnings, warning];
+              lastWarnings = record.warnings;
+              console.warn(warning, error);
             }
-            pool = await loadWorkerPool(
-              preparation,
-              "wasm",
-              record.warnings,
-              linked.controller.signal,
-            );
           }
           throwIfAborted(
             linked.controller.signal,

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/browser-runtime/ai/speech-worker-runtime.mjs

@@ -738,10 +738,9 @@ function validateConfiguration(configuration, role) {
     if (
       descriptorMismatch
       || !Object.hasOwn(descriptors, "device")
-      || (role === "stt" && descriptors.device.value !== "wasm")
-      || (role === "tts"
-        && descriptors.device.value !== "wasm"
-        && descriptors.device.value !== "webgpu")
+      || (descriptors.device.value !== "wasm"
+        && descriptors.device.value !== "webgpu"
+        && descriptors.device.value !== "webnn-npu")
     ) {
       throw workerError(
         "ARCANE_AI_INVALID_REQUEST",
@@ -1367,7 +1366,7 @@ async function createWhisperEngine(namespace, configuration, signal, report) {
     "automatic-speech-recognition",
     configuration.model.repository,
     {
-      device: "wasm",
+      device: configuration.execution?.device ?? "wasm",
       dtype: configuration.model.dtype ?? "fp32",
       revision: configuration.model.revision,
       progress_callback: report,

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.6.0` 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