@almadar/shell-web 1.2.1 → 1.3.0

package/dist/{chunk-ZDRDJKYB.js → chunk-MXN32OVV.js}

@@ -1,30 +1,110 @@
 import { __export, __reExport } from './chunk-G7DCAZ22.js';
+import { instancesForLocale, orbitalInlineEntities, storesRowsInBrowser, isRoutePage, tickEventKey, isJsonObject } from '@almadar/core';
+import { createLogger, isLogLevelEnabled } from '@almadar/logger';
+import { HostAskError, consentFromRedirect, performHostAnswer, hostAskReturn } from '@almadar/shell-runtime/kernel/host';
 import { NativeMemoryPersistenceAdapter } from '@almadar/shell-runtime/persistence/native-memory';
 import * as local_store_transport_star from '@almadar/shell-runtime/runtime/evaluation/local-store-transport';
 import { openLocalKernel as openLocalKernel$1 } from '@almadar/shell-runtime/runtime/evaluation/local-store-transport';
 import { readPageFacts } from '@almadar/shell-browser/page-facts';
-import { instancesForLocale, orbitalInlineEntities, storesRowsInBrowser, isRoutePage, tickEventKey, isJsonObject } from '@almadar/core';
-import { createLogger, isLogLevelEnabled } from '@almadar/logger';
-import { HostAskError, consentFromRedirect, performHostAnswer, hostAskReturn } from '@almadar/shell-runtime/kernel/host';
 import { dispatchDeclaredInput } from '@almadar/shell-runtime/client/declared-input-dispatch';
 import { IndexedDbPersistence } from '@almadar/shell-browser/storage';
 export { eventRouteKey } from '@almadar/shell-runtime/runtime/events/identity/routing';
 export { createResidenceTransport } from '@almadar/shell-runtime/runtime/evaluation/residence-transport';
 
-function hasMemoryStore(kernel) {
-  return "MemoryStore" in kernel;
+var context;
+var buffers = /* @__PURE__ */ new Map();
+var voices = /* @__PURE__ */ new Map();
+function audioContext() {
+  if (context !== void 0) return context;
+  if (typeof AudioContext === "undefined") return void 0;
+  context = new AudioContext();
+  return context;
+}
+function load(ctx, source) {
+  const cached = buffers.get(source);
+  if (cached !== void 0) return cached;
+  const pending = (async () => {
+    const response = await fetch(source);
+    if (!response.ok) throw new Error(`audio/schedule: ${source} did not load (${response.status})`);
+    return ctx.decodeAudioData(await response.arrayBuffer());
+  })();
+  buffers.set(source, pending);
+  pending.catch(() => buffers.delete(source));
+  return pending;
+}
+function begin(ctx, buffer, spec) {
+  const previous = voices.get(spec.key);
+  if (previous !== void 0) previous.source.stop(spec.at);
+  const source = ctx.createBufferSource();
+  const gain = ctx.createGain();
+  source.buffer = buffer;
+  source.playbackRate.value = spec.rate;
+  gain.gain.value = spec.gain;
+  source.connect(gain);
+  gain.connect(ctx.destination);
+  const voice = { source, gain, gainValue: spec.gain, rateValue: spec.rate, ended: false };
+  voices.set(spec.key, voice);
+  source.onended = () => {
+    voice.ended = true;
+  };
+  if (spec.duration !== void 0) source.start(spec.at, spec.offset, spec.duration);
+  else source.start(spec.at, spec.offset);
+}
+async function scheduleAudio(commands) {
+  const ctx = audioContext();
+  if (ctx === void 0) throw new HostAskError("unavailable", "audio/schedule: this environment has no AudioContext");
+  const known = new Set(voices.keys());
+  for (const command of commands) {
+    if ("start" in command) known.add(command.start.key);
+    else if ("stop" in command) {
+      if (!known.has(command.stop.key)) throw new HostAskError("invalid", `audio/schedule: no voice named ${command.stop.key} was started`);
+      known.delete(command.stop.key);
+    } else if (!known.has(command.ramp.key)) throw new HostAskError("invalid", `audio/schedule: no voice named ${command.ramp.key} was started`);
+  }
+  try {
+    await ctx.resume();
+    const decoded = /* @__PURE__ */ new Map();
+    for (const command of commands) {
+      if ("start" in command && !decoded.has(command.start.source)) decoded.set(command.start.source, await load(ctx, command.start.source));
+    }
+    for (const command of commands) {
+      if ("start" in command) {
+        const buffer = decoded.get(command.start.source);
+        if (buffer === void 0) throw new HostAskError("unavailable", `audio/schedule: ${command.start.source} was not decoded`);
+        begin(ctx, buffer, command.start);
+        continue;
+      }
+      const key = "stop" in command ? command.stop.key : command.ramp.key;
+      const voice = voices.get(key);
+      if (voice === void 0) throw new HostAskError("invalid", `audio/schedule: no voice named ${key} was started`);
+      if ("stop" in command) {
+        if (!voice.ended) voice.source.stop(command.stop.at);
+        voices.delete(key);
+        continue;
+      }
+      if (voice.ended) continue;
+      const { param, value, at, endAt, curve } = command.ramp;
+      const target = param === "gain" ? voice.gain.gain : voice.source.playbackRate;
+      target.setValueAtTime(param === "gain" ? voice.gainValue : voice.rateValue, at);
+      if (curve === "linear") target.linearRampToValueAtTime(value, endAt);
+      else target.exponentialRampToValueAtTime(value, endAt);
+      if (param === "gain") voice.gainValue = value;
+      else voice.rateValue = value;
+    }
+  } catch (error) {
+    if (error instanceof HostAskError) throw error;
+    throw new HostAskError("unavailable", error instanceof Error ? error.message : String(error));
+  }
 }
-function nativeMemoryPersistence(kernel) {
-  if (!hasMemoryStore(kernel)) throw new Error("nativeMemoryPersistence: this kernel module exports no MemoryStore; install a kernel build that carries it");
-  return new NativeMemoryPersistenceAdapter(new kernel.MemoryStore());
+async function readAudioClock() {
+  const ctx = audioContext();
+  if (ctx === void 0) throw new HostAskError("unavailable", "audio/clock: this environment has no AudioContext");
+  if (typeof ctx.getOutputTimestamp === "function") {
+    const { contextTime, performanceTime } = ctx.getOutputTimestamp();
+    if (contextTime !== void 0 && performanceTime !== void 0) return { audio: contextTime, wall: performance.timeOrigin + performanceTime };
+  }
+  return { audio: ctx.currentTime, wall: performance.timeOrigin + performance.now() };
 }
-
-// src/runtime/evaluation/local-store-transport.ts
-var local_store_transport_exports = {};
-__export(local_store_transport_exports, {
-  openLocalKernel: () => openLocalKernel
-});
-__reExport(local_store_transport_exports, local_store_transport_star);
 var POLL_MS = 250;
 function consentByPopup(env) {
   return async (request) => {
@@ -94,6 +174,8 @@ var webHostActions = {
   get signIn() {
     return signInHost;
   },
+  audioSchedule: scheduleAudio,
+  audioClock: readAudioClock,
   get consent() {
     return consentHost ?? (typeof window === "undefined" ? void 0 : consentByPopup(browserConsentEnv(window)));
   }
@@ -110,11 +192,13 @@ function streamTrace(args, completion, dispatch, source) {
   const named = options !== void 0 && options !== null && isJsonObject(options) ? options["traits"] : void 0;
   const traits = Array.isArray(named) ? named.flatMap((t) => typeof t === "string" ? [t] : []) : [];
   if (traits.length === 0) return refuse("program/live trace: name the traits it observes in `traits`");
+  const cost = options !== void 0 && options !== null && isJsonObject(options) ? options["cost"] : void 0;
+  if (cost !== void 0 && cost !== null && typeof cost !== "boolean") return refuse("program/live trace: cost must be a boolean when supplied");
   if (source === void 0 || dispatch === void 0) return refuse("program/live trace: this host has no kernel trace to stream");
   if (traceStreams.has(key)) return refuse(`key ${key} already has a stream open`);
   traceStreams.set(key, source(traits, (item) => {
     void dispatch(trait, onMessage, { ...item, key, ...completion.entityId !== void 0 ? { entityId: completion.entityId } : {} }).catch((error) => log.error("trace item return failed", { trait, key, error: error.message }));
-  }));
+  }, cost === true));
 }
 function cancelStreams(args) {
   const named = args[0];
@@ -138,8 +222,20 @@ async function answerHostAsk(op, args, completion, dispatch, trace) {
   }
   await dispatch(returned.trait, returned.event, returned.entityId !== void 0 ? { ...returned.payload, entityId: returned.entityId } : returned.payload);
 }
+function hasMemoryStore(kernel) {
+  return "MemoryStore" in kernel;
+}
+function nativeMemoryPersistence(kernel) {
+  if (!hasMemoryStore(kernel)) throw new Error("nativeMemoryPersistence: this kernel module exports no MemoryStore; install a kernel build that carries it");
+  return new NativeMemoryPersistenceAdapter(new kernel.MemoryStore());
+}
 
 // src/runtime/evaluation/local-store-transport.ts
+var local_store_transport_exports = {};
+__export(local_store_transport_exports, {
+  openLocalKernel: () => openLocalKernel
+});
+__reExport(local_store_transport_exports, local_store_transport_star);
 function openLocalKernel(options) {
   return openLocalKernel$1({ ...options, pageFacts: options.pageFacts ?? readPageFacts, hostActions: options.hostActions ?? webHostActions });
 }
@@ -205,14 +301,110 @@ async function persistedMemory(kernel, database, entities, locale) {
 function browserStoreName(appName, locale) {
   return locale !== void 0 ? `almadar:${appName}:${locale}` : `almadar:${appName}`;
 }
-async function openBrowserStore(databaseName, orbitals, factory) {
+function tableOf(entity) {
+  return entity.collection ?? entity.name;
+}
+async function moveTypeStores(factory, databaseName, entities) {
+  const collections = new Set(entities.map(tableOf));
+  const current = await new Promise((resolve, reject) => {
+    const req = factory.open(databaseName);
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+  const stale = entities.filter((e) => tableOf(e) !== e.name && !collections.has(e.name) && current.objectStoreNames.contains(e.name));
+  const next = current.version + 1;
+  current.close();
+  if (stale.length === 0) return;
+  await new Promise((resolve, reject) => {
+    const req = factory.open(databaseName, next);
+    req.onupgradeneeded = () => {
+      const db = req.result;
+      const tx = req.transaction;
+      if (tx === null) return;
+      const moveOne = (index) => {
+        const entity = stale[index];
+        if (entity === void 0) return;
+        const target = tableOf(entity);
+        if (!db.objectStoreNames.contains(target)) db.createObjectStore(target, { keyPath: "id" });
+        const old = tx.objectStore(entity.name);
+        const destination = tx.objectStore(target);
+        const rows = old.getAll();
+        rows.onsuccess = () => {
+          const keys = destination.getAllKeys();
+          keys.onsuccess = () => {
+            const present = new Set(keys.result);
+            for (const row of rows.result) if (!present.has(row.id)) destination.put(row);
+            db.deleteObjectStore(entity.name);
+            moveOne(index + 1);
+          };
+        };
+      };
+      moveOne(0);
+    };
+    req.onsuccess = () => {
+      req.result.close();
+      resolve();
+    };
+    req.onerror = () => reject(req.error);
+    req.onblocked = () => reject(new Error(`browser store "${databaseName}" is open in another context and cannot be upgraded`));
+  });
+}
+async function adoptDatabase(factory, formerName, entities, target) {
+  await moveTypeStores(factory, formerName, entities);
+  const tables = [...new Set(entities.map(tableOf))];
+  const former = await new Promise((resolve, reject) => {
+    const req = factory.open(formerName);
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+  const held = /* @__PURE__ */ new Map();
+  try {
+    for (const table of tables) {
+      if (!former.objectStoreNames.contains(table)) continue;
+      const rows = await new Promise((resolve, reject) => {
+        const req = former.transaction(table, "readonly").objectStore(table).getAll();
+        req.onsuccess = () => resolve(req.result);
+        req.onerror = () => reject(req.error);
+      });
+      held.set(table, rows);
+    }
+  } finally {
+    former.close();
+  }
+  for (const [table, rows] of held) {
+    const present = new Set((await target.list(table)).map((row) => row.id));
+    for (const row of rows) if (!present.has(row.id)) await target.create(table, row);
+  }
+  await new Promise((resolve, reject) => {
+    const req = factory.deleteDatabase(formerName);
+    req.onsuccess = () => resolve();
+    req.onerror = () => reject(req.error);
+    req.onblocked = () => reject(new Error(`browser store "${formerName}" is open in another context and cannot be removed`));
+  });
+}
+async function openBrowserStore(databaseName, orbitals, factory, formerDatabaseName) {
   const entities = orbitals.flatMap(orbitalInlineEntities).filter(storesRowsInBrowser);
   if (entities.length === 0) return null;
-  return IndexedDbPersistence.open({
+  const idb = factory ?? globalThis.indexedDB;
+  if (!idb) throw new Error("IndexedDbPersistence: this environment has no IndexedDB");
+  await moveTypeStores(idb, databaseName, entities);
+  const tables = new Map(entities.map((e) => [e.name, tableOf(e)]));
+  const table = (entityType) => tables.get(entityType) ?? entityType;
+  const database = await IndexedDbPersistence.open({
     databaseName,
-    entityTypes: entities.map((e) => e.name),
-    ...factory !== void 0 ? { factory } : {}
+    entityTypes: [...new Set(tables.values())],
+    factory: idb
   });
+  if (formerDatabaseName !== void 0 && formerDatabaseName !== databaseName) {
+    await adoptDatabase(idb, formerDatabaseName, entities, database);
+  }
+  return {
+    create: (entityType, data) => database.create(table(entityType), data),
+    delete: (entityType, id) => database.delete(table(entityType), id),
+    list: (entityType) => database.list(table(entityType)),
+    changes: () => database.changes(),
+    close: () => database.close()
+  };
 }
 function browserEntities(orbitals) {
   return orbitals.flatMap(orbitalInlineEntities).filter(storesRowsInBrowser);