arcane-os 0.2.0 → 0.2.1

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.2.1
+
+- Added explicit selected-unloaded chat activation, truthful legacy Cloud/Core
+  route readiness, and provider-native chat-response normalization without
+  startup downloads, hidden provider selection, or application policy.
+- Normalized shared STT/TTS requests at the browser-speech provider boundary
+  while retaining caller-supplied immutable runtime, model, and voice
+  authorities and fail-closed format, lifecycle, error, and cancellation rules.
+- Applied authenticated dependency import maps to every packaged browser
+  document and published a deterministic browser-readable runtime projection
+  inventory derived from the verified package receipt.
+- Added caller-budgeted complete DBOPFS source evaluation with deterministic
+  zero-score fallback, independent scoring/excerpt/output bounds, and opt-in
+  preserve-readable bootstrap/evaluation read coverage.
+- Bound external workspace validation, packaging, scaffolding, doctor,
+  toolchain, and development serving to one authenticated installed package,
+  including the exact `arcane-sdk@npm:arcane-os@0.2.1` alias form.
+
 ## 0.2.0
 
 - Made the SDK the canonical owner of the portable Arcane runtime and retired

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.2.0` SDK contract. Applications pin one exact npm
+This checkout defines the `0.2.1` SDK contract. Applications pin one exact npm
 version and lockfile; registry state is deliberately not baked into immutable
 application artifacts.
 
@@ -132,7 +132,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.2.0 new my-app --path ./my-app --target portable --git
+npx arcane-os@0.2.1 new my-app --path ./my-app --target portable --git
 cd my-app
 npm install
 npm run check
@@ -143,7 +143,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.2.0
+npm install --save-dev --save-exact arcane-os@0.2.1
 npm exec -- arcane init my-app --target portable
 ```
 
@@ -159,7 +159,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.2.0` for the initial bootstrap because it names this npm
+Use `npx arcane-os@0.2.1` 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`,
@@ -180,7 +180,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.2.0.tgz
+npm install --save-dev --save-exact ../arcane-os-sdk/arcane-os-0.2.1.tgz
 npm run check
 npm ci
 ```
@@ -191,7 +191,7 @@ still verifies the installed package name and exact version, the locked runtime
 identity, and the runtime bytes. 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.2.0` registry package and
+the local declaration with the exact `arcane-os@0.2.1` registry package and
 commit the regenerated lock.
 
 Generated repositories use `npm ci --ignore-scripts` in CI. Run dependency
@@ -304,7 +304,7 @@ recorded length through a final identity check; an appended byte, concurrent
 growth, path replacement, or hard link fails closed. NFC paths use defined
 UTF-8 byte ordering, covered by one pinned golden bundle digest on every
 supported Node/runner combination. This SDK accepts only the explicitly listed
-`0.2.0` bundle generation; structural validity does not imply cross-SDK
+`0.2.1` bundle generation; structural validity does not imply cross-SDK
 compatibility, and a release with zero payload bytes cannot be created. Portable
 path validation rejects file/directory prefix conflicts, case-colliding prefix
 spellings, and Windows device aliases including superscript COM/LPT digits.
@@ -350,7 +350,7 @@ package installation, or assertions.
 
 ## Current target support
 
-Version `0.2.0` exposes one browser target and five explicitly paired
+Version `0.2.1` exposes one browser target and five explicitly paired
 native development targets: a verified 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/ARCANE_SDK_BROWSER_RELEASE.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "builder": "arcane-sdk-browser-runtime-v1",
-  "sdkVersion": "0.2.0",
+  "sdkVersion": "0.2.1",
   "source": {
     "authority": "arcane-os-sdk",
     "repository": "https://github.com/TheWizardNexus/arcane-os-sdk.git",
@@ -29,8 +29,8 @@
     ]
   },
   "fileCount": 25,
-  "totalBytes": 9269048,
-  "contentSha256": "d965eaf3ccf12593ae2628e7549794f4efbf1aa4cf56a39f51cc3869f0852671",
+  "totalBytes": 9279974,
+  "contentSha256": "a9715c4b3aef70ec4042e4738089568d6588877b29582e0f758ed83897b6814f",
   "files": [
     {
       "path": "ai/ARCANE_AI_BROWSER_WASM_COMPONENTS.json",
@@ -57,8 +57,8 @@
       "path": "ai/browser-speech-providers.mjs",
       "sourcePath": "browser-runtime/ai/browser-speech-providers.mjs",
       "provenance": "sdk-source-identity",
-      "bytes": 15056,
-      "sha256": "1eac35e1ca895e8862853a63def2cbf275fbbfe9ee6b1d36573a8dfa5f8924c6"
+      "bytes": 25982,
+      "sha256": "65e0a8da2bcd46b11c3ea2ca496105875977decc53d4e4c94ca56949dbb569b1"
     },
     {
       "path": "ai/browser-speech.mjs",

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

@@ -15,6 +15,9 @@ import {
 
 const AI_PROVIDER_PROTOCOL = "arcane-ai-provider/2";
 const ROLE_OPERATION = Object.freeze({ stt: "transcribe", tts: "synthesize" });
+const STT_SAMPLE_RATE = 16_000;
+const TTS_SAMPLE_RATE = 24_000;
+const TTS_RESPONSE_FORMAT = "wav";
 const WORKER_FAILURE_CODES = new Set([
   "ARCANE_AI_WORKER_CRASHED",
   "ARCANE_AI_WORKER_MESSAGE_ERROR",
@@ -82,23 +85,237 @@ function publicStatus({ role, id, authority, state, busy, generation, errorCode,
   });
 }
 
-function cloneRequestPayload(role, payload, authority) {
-  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
-    throw providerError("ARCANE_AI_INVALID_REQUEST", "Speech request payload must be an object.");
+function assertRequestAuthority(context, authority, providerId) {
+  if (!Object.hasOwn(context, "selection")) return;
+  const selection = context.selection;
+  if (selection?.providerId !== providerId
+    || selection?.modelId !== authority.modelId
+    || selection?.localOnly === false) {
+    throw providerError(
+      "ARCANE_AI_MODEL_AUTHORITY_REQUIRED",
+      "The browser speech request selection changed from its immutable provider authority.",
+    );
   }
-  if (role === "stt") {
-    if (!(payload.audio instanceof Float32Array) || payload.sampleRate !== 16_000) {
+}
+
+function assertPayloadModel(payload, authority, { required = false } = {}) {
+  if (!Object.hasOwn(payload, "model")) {
+    if (!required) return;
+    throw providerError(
+      "ARCANE_AI_MODEL_AUTHORITY_REQUIRED",
+      "The shared speech request must identify the provider's immutable model authority.",
+    );
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(payload, "model");
+  if (!Object.hasOwn(descriptor ?? {}, "value") || descriptor.value !== authority.modelId) {
+    throw providerError(
+      "ARCANE_AI_MODEL_AUTHORITY_REQUIRED",
+      "The shared speech request model does not match this provider authority.",
+    );
+  }
+}
+
+function genericPayloadDescriptors(payload, allowedKeys, requiredKeys, label) {
+  const prototype = Object.getPrototypeOf(payload);
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw providerError("ARCANE_AI_INVALID_REQUEST", `${label} must be a plain object.`);
+  }
+  const descriptors = Object.getOwnPropertyDescriptors(payload);
+  for (const key of Reflect.ownKeys(descriptors)) {
+    if (typeof key === "symbol" || !allowedKeys.includes(key)) {
+      throw providerError("ARCANE_AI_INVALID_REQUEST", `${label} contains an unknown field.`);
+    }
+    if (!Object.hasOwn(descriptors[key], "value")) {
+      throw providerError("ARCANE_AI_INVALID_REQUEST", `${label}.${key} must be a data property.`);
+    }
+  }
+  for (const key of requiredKeys) {
+    if (!Object.hasOwn(descriptors, key)) {
+      throw providerError("ARCANE_AI_INVALID_REQUEST", `${label}.${key} is required.`);
+    }
+  }
+  return descriptors;
+}
+
+function audioMimeEssence(value, label) {
+  if (typeof value !== "string") {
+    throw providerError("ARCANE_AI_INVALID_REQUEST", `${label} must be an audio MIME type.`);
+  }
+  const essence = value.split(";", 1)[0].trim().toLowerCase();
+  if (!/^audio\/[a-z0-9!#$%&'*+.^_`|~-]+$/u.test(essence)) {
+    throw providerError("ARCANE_AI_INVALID_REQUEST", `${label} must be an audio MIME type.`);
+  }
+  return essence;
+}
+
+function awaitAbortableSpeechOperation(operation, signal) {
+  const observed = Promise.resolve(operation);
+  if (!signal) return observed;
+  if (signal.aborted) {
+    // Blob and Web Audio operations cannot be preempted; retain their eventual
+    // rejection after cancellation instead of leaving an unobserved promise.
+    observed.catch(function retainCancelledSpeechOperation() {});
+    return Promise.reject(abortError(signal));
+  }
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const release = () => signal.removeEventListener("abort", cancel);
+    const settle = (callback, value) => {
+      if (settled) return;
+      settled = true;
+      release();
+      callback(value);
+    };
+    const cancel = () => settle(reject, abortError(signal));
+    signal.addEventListener("abort", cancel, { once: true });
+    observed.then(
+      (value) => settle(resolve, value),
+      (error) => settle(reject, error),
+    );
+  });
+}
+
+async function decodeSharedTranscriptionPayload(payload, authority, signal) {
+  const descriptors = genericPayloadDescriptors(
+    payload,
+    ["audio", "mimeType", "model"],
+    ["audio", "mimeType", "model"],
+    "Shared speech transcription payload",
+  );
+  assertPayloadModel(payload, authority, { required: true });
+  const audio = descriptors.audio.value;
+  if (typeof Blob !== "function" || !(audio instanceof Blob) || audio.size < 1) {
+    throw providerError(
+      "ARCANE_AI_INVALID_REQUEST",
+      "Shared speech transcription requires a nonempty audio Blob or File.",
+    );
+  }
+  const mimeType = audioMimeEssence(descriptors.mimeType.value, "Speech transcription mimeType");
+  if (audio.type && audioMimeEssence(audio.type, "Speech transcription Blob.type") !== mimeType) {
+    throw providerError(
+      "ARCANE_AI_INVALID_REQUEST",
+      "Speech transcription mimeType does not match the audio Blob type.",
+    );
+  }
+  const OfflineAudioContext = globalThis.OfflineAudioContext
+    ?? globalThis.webkitOfflineAudioContext;
+  if (typeof OfflineAudioContext !== "function") {
+    throw providerError(
+      "ARCANE_AI_AUDIO_DECODE_UNAVAILABLE",
+      "Shared Blob transcription requires OfflineAudioContext decoding at 16000 Hz.",
+    );
+  }
+  let decoder;
+  try {
+    decoder = new OfflineAudioContext(1, 1, STT_SAMPLE_RATE);
+  } catch (error) {
+    throw providerError(
+      "ARCANE_AI_AUDIO_DECODE_UNAVAILABLE",
+      "Unable to create the required 16000 Hz speech decoder.",
+      error,
+    );
+  }
+  if (typeof decoder.decodeAudioData !== "function") {
+    throw providerError(
+      "ARCANE_AI_AUDIO_DECODE_UNAVAILABLE",
+      "Shared Blob transcription requires browser audio decoding.",
+    );
+  }
+  let decoded;
+  try {
+    const encoded = await awaitAbortableSpeechOperation(audio.arrayBuffer(), signal);
+    throwIfAborted(signal);
+    decoded = await awaitAbortableSpeechOperation(decoder.decodeAudioData(encoded), signal);
+    throwIfAborted(signal);
+  } catch (error) {
+    if (signal?.aborted && error?.code === "ARCANE_AI_REQUEST_ABORTED") throw error;
+    throw providerError(
+      "ARCANE_AI_AUDIO_DECODE_FAILED",
+      "The browser could not decode the supplied speech audio.",
+      error,
+    );
+  }
+  if (decoded?.sampleRate !== STT_SAMPLE_RATE
+    || !Number.isSafeInteger(decoded.length)
+    || decoded.length < 1
+    || !Number.isSafeInteger(decoded.numberOfChannels)
+    || decoded.numberOfChannels < 1
+    || typeof decoded.getChannelData !== "function") {
+    throw providerError(
+      "ARCANE_AI_AUDIO_DECODE_FAILED",
+      "Decoded speech audio must provide nonempty 16000 Hz channel data.",
+    );
+  }
+  const channels = [];
+  for (let index = 0; index < decoded.numberOfChannels; index += 1) {
+    const channel = decoded.getChannelData(index);
+    if (!(channel instanceof Float32Array) || channel.length !== decoded.length) {
       throw providerError(
-        "ARCANE_AI_INVALID_REQUEST",
-        "Whisper requires Float32Array audio sampled at exactly 16000 Hz.",
+        "ARCANE_AI_AUDIO_DECODE_FAILED",
+        "Decoded speech audio returned invalid channel data.",
       );
     }
-    return Object.freeze({
+    channels.push(channel);
+  }
+  const mono = new Float32Array(decoded.length);
+  for (let index = 0; index < mono.length; index += 1) {
+    let sample = 0;
+    for (const channel of channels) sample += channel[index];
+    sample /= channels.length;
+    if (!Number.isFinite(sample)) {
+      throw providerError(
+        "ARCANE_AI_AUDIO_DECODE_FAILED",
+        "Decoded speech audio contains a non-finite sample.",
+      );
+    }
+    mono[index] = sample;
+  }
+  throwIfAborted(signal);
+  return Object.freeze({
+    payload: Object.freeze({ audio: mono, sampleRate: STT_SAMPLE_RATE }),
+    shared: true,
+  });
+}
+
+function cloneNativeTranscriptionPayload(payload, authority) {
+  assertPayloadModel(payload, authority);
+  if (!(payload.audio instanceof Float32Array) || payload.sampleRate !== STT_SAMPLE_RATE) {
+    throw providerError(
+      "ARCANE_AI_INVALID_REQUEST",
+      "Whisper requires Float32Array audio sampled at exactly 16000 Hz.",
+    );
+  }
+  return Object.freeze({
+    payload: Object.freeze({
       audio: new Float32Array(payload.audio),
-      sampleRate: 16_000,
-    });
+      sampleRate: STT_SAMPLE_RATE,
+    }),
+    shared: false,
+  });
+}
+
+function normalizeSynthesisPayload(payload, authority) {
+  const shared = Object.hasOwn(payload, "input");
+  let textValue = payload.text;
+  if (shared) {
+    const descriptors = genericPayloadDescriptors(
+      payload,
+      ["model", "voice", "input", "responseFormat", "speed"],
+      ["model", "input", "responseFormat"],
+      "Shared speech synthesis payload",
+    );
+    assertPayloadModel(payload, authority, { required: true });
+    if (descriptors.responseFormat.value !== TTS_RESPONSE_FORMAT) {
+      throw providerError(
+        "ARCANE_AI_UNSUPPORTED_RESPONSE_FORMAT",
+        "Browser Kokoro supports only wav responses for shared speech requests.",
+      );
+    }
+    textValue = descriptors.input.value;
+  } else {
+    assertPayloadModel(payload, authority);
   }
-  const text = typeof payload.text === "string" ? payload.text.trim() : "";
+  const text = typeof textValue === "string" ? textValue.trim() : "";
   const voice = typeof (payload.voice ?? authority.defaultVoice) === "string"
     ? (payload.voice ?? authority.defaultVoice).trim()
     : "";
@@ -109,7 +326,75 @@ function cloneRequestPayload(role, payload, authority) {
       "Kokoro requires text, a voice, and speed greater than 0 and at most 4.",
     );
   }
-  return Object.freeze({ text, voice, speed });
+  return Object.freeze({
+    payload: Object.freeze({ text, voice, speed }),
+    shared,
+  });
+}
+
+async function normalizeRequestPayload(role, payload, authority, signal) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    throw providerError("ARCANE_AI_INVALID_REQUEST", "Speech request payload must be an object.");
+  }
+  if (role === "stt") {
+    const audio = Object.getOwnPropertyDescriptor(payload, "audio");
+    if (Object.hasOwn(audio ?? {}, "value")
+      && typeof Blob === "function"
+      && audio.value instanceof Blob) {
+      return decodeSharedTranscriptionPayload(payload, authority, signal);
+    }
+    return cloneNativeTranscriptionPayload(payload, authority);
+  }
+  return normalizeSynthesisPayload(payload, authority);
+}
+
+function encodeSharedSynthesisResult(result) {
+  if (!(result?.audio instanceof Float32Array)
+    || result.sampleRate !== TTS_SAMPLE_RATE
+    || result.audio.length < 1
+    || result.audio.length > (0xffffffff - 44) / 2) {
+    throw providerError(
+      "ARCANE_AI_INVALID_PROVIDER_RESULT",
+      "Browser Kokoro must return nonempty 24000 Hz Float32 PCM.",
+    );
+  }
+  const buffer = new ArrayBuffer(44 + result.audio.length * 2);
+  const bytes = new Uint8Array(buffer);
+  const view = new DataView(buffer);
+  const writeText = (offset, value) => {
+    for (let index = 0; index < value.length; index += 1) {
+      view.setUint8(offset + index, value.charCodeAt(index));
+    }
+  };
+  writeText(0, "RIFF");
+  view.setUint32(4, buffer.byteLength - 8, true);
+  writeText(8, "WAVE");
+  writeText(12, "fmt ");
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true);
+  view.setUint16(22, 1, true);
+  view.setUint32(24, TTS_SAMPLE_RATE, true);
+  view.setUint32(28, TTS_SAMPLE_RATE * 2, true);
+  view.setUint16(32, 2, true);
+  view.setUint16(34, 16, true);
+  writeText(36, "data");
+  view.setUint32(40, result.audio.length * 2, true);
+  for (let index = 0; index < result.audio.length; index += 1) {
+    const sample = result.audio[index];
+    if (!Number.isFinite(sample)) {
+      throw providerError(
+        "ARCANE_AI_INVALID_PROVIDER_RESULT",
+        "Browser Kokoro returned a non-finite PCM sample.",
+      );
+    }
+    const clamped = Math.max(-1, Math.min(1, sample));
+    view.setInt16(
+      44 + index * 2,
+      Math.round(clamped < 0 ? clamped * 0x8000 : clamped * 0x7fff),
+      true,
+    );
+  }
+  return Object.freeze({ audio: bytes, contentType: "audio/wav" });
 }
 
 function createBrowserSpeechProvider({
@@ -152,6 +437,13 @@ function createBrowserSpeechProvider({
     throw new TypeError("Browser speech authority construction failed.");
   }
   const operation = ROLE_OPERATION[role];
+  const speech = role === "stt"
+    ? Object.freeze({ inputSampleRate: STT_SAMPLE_RATE })
+    : Object.freeze({
+      outputSampleRate: TTS_SAMPLE_RATE,
+      responseFormats: Object.freeze([TTS_RESPONSE_FORMAT]),
+      defaultResponseFormat: TTS_RESPONSE_FORMAT,
+    });
   const catalogEntry = Object.freeze({
     id: authority.modelId,
     providerId,
@@ -161,6 +453,7 @@ function createBrowserSpeechProvider({
     revision: authority.revision,
     runtime: authority.runtime,
     files: authority.files,
+    speech,
   });
   let state = "unloaded";
   let errorCode = null;
@@ -362,6 +655,7 @@ function createBrowserSpeechProvider({
       if (context.role !== role || context.operation !== operation) {
         throw providerError("ARCANE_AI_INVALID_REQUEST", `Browser ${role} supports only ${operation}.`);
       }
+      assertRequestAuthority(context, authority, providerId);
       const externalSignal = context.signal ?? null;
       throwIfAborted(externalSignal);
       if (state !== "ready" || !active) {
@@ -370,10 +664,6 @@ function createBrowserSpeechProvider({
       if (requestOperation) {
         throw providerError("ARCANE_AI_PROVIDER_BUSY", "The browser speech provider is already processing a request.");
       }
-      const payload = cloneRequestPayload(role, context.payload, {
-        defaultVoice: authority.defaultVoice,
-      });
-      throwIfAborted(externalSignal);
       const linked = linkSignal(externalSignal);
       if (linked.controller.signal.aborted) {
         linked.release();
@@ -381,21 +671,36 @@ function createBrowserSpeechProvider({
       }
       const slot = active;
       const requestGeneration = generation;
-      const promise = slot.client.request("use", payload, {
-        signal: linked.controller.signal,
-      });
+      let workerRequestStarted = false;
+      const promise = (async () => {
+        const normalized = await normalizeRequestPayload(
+          role,
+          context.payload,
+          authority,
+          linked.controller.signal,
+        );
+        throwIfAborted(linked.controller.signal);
+        workerRequestStarted = true;
+        const result = await slot.client.request("use", normalized.payload, {
+          signal: linked.controller.signal,
+        });
+        if (requestGeneration !== generation || active !== slot) {
+          throw providerError("ARCANE_AI_OPERATION_SUPERSEDED", "The browser speech result was superseded.");
+        }
+        return role === "tts" && normalized.shared
+          ? encodeSharedSynthesisResult(result)
+          : result;
+      })();
       requestOperation = Object.freeze({
         promise,
         abort: () => linked.controller.abort(),
       });
       try {
-        const result = await promise;
-        if (requestGeneration !== generation || active !== slot) {
-          throw providerError("ARCANE_AI_OPERATION_SUPERSEDED", "The browser speech result was superseded.");
-        }
-        return result;
+        return await promise;
       } catch (error) {
-        if (error?.code === "ARCANE_AI_REQUEST_ABORTED" && active === slot) {
+        if (error?.code === "ARCANE_AI_REQUEST_ABORTED"
+          && workerRequestStarted
+          && active === slot) {
           active = null;
           releaseSlot(slot);
           state = "unloaded";

package/docs/architecture.md

@@ -200,7 +200,7 @@ length with an EOF growth probe, and rechecked by handle and pathname identity.
 Every cumulative path prefix has one case-folded spelling and one file/directory
 kind; prefix topology conflicts and the complete portable Windows device-name
 set fail before creation or admission.
-The current SDK admits only the explicitly compatible `0.2.0` bundle
+The current SDK admits only the explicitly compatible `0.2.1` bundle
 generation and rejects zero-byte payload releases.
 
 Promotion retains any prior output as an identity-bound backup until the new
@@ -320,7 +320,7 @@ through SDK-bound verified readers rather than accepting a mutable source path
 as authority. Build completion requires provider verification, and later
 verify/run calls receive the exact artifact receipt.
 
-The SDK `0.2.0` runtime requires Arcane `0.8.12` or newer. Compatibility
+The SDK `0.2.1` 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/package.json

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

package/runtime/ARCANE_RUNTIME_RELEASE.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "builder": "arcane-sdk-runtime-v1",
-  "sdkVersion": "0.2.0",
+  "sdkVersion": "0.2.1",
   "source": {
     "authority": "sdk-canonical",
     "repository": "https://github.com/TheWizardNexus/arcane-os-sdk.git",
@@ -14,8 +14,8 @@
     }
   },
   "fileCount": 160,
-  "totalBytes": 3549207,
-  "contentSha256": "fa3bcddb5479817971a400049dbeff8431c6499d708e9a8b714176715c5a015a",
+  "totalBytes": 3605154,
+  "contentSha256": "5b921d50b6a0cf36a13f7a7dedf96cd3a68104a322e5139136fd4197aa1ca7cb",
   "files": [
     {
       "path": "arcane/components/app-bar.html",
@@ -39,8 +39,8 @@
     },
     {
       "path": "arcane/components/chat.html",
-      "bytes": 52132,
-      "sha256": "42d4769a074e70b5c2768e850eaf29a25c93ee9e8734724b72b2ad585e19b2ca"
+      "bytes": 61650,
+      "sha256": "d644848fbc3ccc85d491db7ada75231f393a371dd3a0ccd92f223c172571e47b"
     },
     {
       "path": "arcane/components/conversation-view.html",
@@ -374,8 +374,8 @@
     },
     {
       "path": "arcane/modules/AI.js",
-      "bytes": 81061,
-      "sha256": "8e34445ad394064dae970583147b635de81d878a6caebb8a60d64b34dbc9e658"
+      "bytes": 103733,
+      "sha256": "3a051d67b1e895b7c6f14af36a34daf1d92fe70e02c95c1c4ffd80cc7c622561"
     },
     {
       "path": "arcane/modules/AIPreferenceRuntime.js",
@@ -499,8 +499,8 @@
     },
     {
       "path": "arcane/modules/ConfiguredAIChatSession.js",
-      "bytes": 21462,
-      "sha256": "12e02b169be6867d82ef8be75bcb1c2b367e778609e8d065389ed109d896c4c8"
+      "bytes": 24501,
+      "sha256": "f95c3421bf07397e987f77fc3d02166cf780059dd3d6de90ceaded990752f51b"
     },
     {
       "path": "arcane/modules/ConversationActionItems.js",
@@ -534,8 +534,8 @@
     },
     {
       "path": "arcane/modules/DBOPFSDocumentLibrary.js",
-      "bytes": 29977,
-      "sha256": "4c551b5917d1577b8b46b08457cf762d7ab7548222abd6f4a72c7c7ab5c697b7"
+      "bytes": 50695,
+      "sha256": "2831470ce54c3393595bf068d60c2e774804cbd51dba7491ad734bbfbea7f32f"
     },
     {
       "path": "arcane/modules/DBOPFSWorker.js",