@lunora/solid 1.0.0-alpha.3 → 1.0.0-alpha.30

package/dist/packem_shared/{createMutation-C7BxzO0y.mjs → createMutation-LkrbhItI.mjs}

@@ -1,6 +1,6 @@
 import { createMutationRunner } from '@lunora/client';
 import { createSignal } from 'solid-js';
-import { useLunora } from './LunoraContext-C9SpKj54.mjs';
+import { useLunora } from './LunoraContext-C59PzHhN.mjs';
 
 const createMutationForClient = (client, function_) => {
   const [data, setData] = createSignal(void 0);

package/dist/packem_shared/createMutator-foSnPJPt.mjs

@@ -0,0 +1,24 @@
+import { createMutatorRunner } from '@lunora/client';
+import { createSignal } from 'solid-js';
+
+const createMutator = (handle) => {
+  const [error, setError] = createSignal(void 0);
+  const [pending, setPending] = createSignal(false);
+  const {
+    mutate,
+    reset
+  } = createMutatorRunner(handle, {
+    setError,
+    setPending
+  });
+  const isError = () => error() !== void 0;
+  return {
+    error,
+    isError,
+    mutate,
+    pending,
+    reset
+  };
+};
+
+export { createMutator };

package/dist/packem_shared/{createPresence-DiAak1Jw.mjs → createPresence-DM2cVkiG.mjs}

@@ -1,12 +1,19 @@
 import { createSignal, onMount, onCleanup } from 'solid-js';
-import { useLunora } from './LunoraContext-C9SpKj54.mjs';
+import { useLunora } from './LunoraContext-C59PzHhN.mjs';
 
-const makeSessionId = () => {
-  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
-    return crypto.randomUUID();
+const randomSessionId = (prefix = "sess") => {
+  if (typeof crypto !== "undefined") {
+    if (typeof crypto.randomUUID === "function") {
+      return crypto.randomUUID();
+    }
+    if (typeof crypto.getRandomValues === "function") {
+      const bytes = crypto.getRandomValues(new Uint8Array(16));
+      return `${prefix}-${Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+    }
   }
-  return `sess-${Math.random().toString(36).slice(2)}-${String(Date.now())}`;
+  return `${prefix}-${Date.now().toString(36)}`;
 };
+
 const DEFAULT_INTERVAL_MS = 1e4;
 const createPresence = (roomId, options) => {
   const client = useLunora();
@@ -16,7 +23,7 @@ const createPresence = (roomId, options) => {
     listPresent,
     shardKey
   } = options;
-  const sessionId = options.sessionId ?? makeSessionId();
+  const sessionId = options.sessionId ?? randomSessionId();
   const [present, setPresent] = createSignal(void 0);
   let latestData = options.data;
   const sendHeartbeat = () => {

package/dist/packem_shared/{createQuery-D8mdHfyQ.mjs → createQuery-BUldvZXj.mjs}

@@ -1,6 +1,6 @@
 import { createQuerySubscription } from '@lunora/client/query';
 import { createSignal, createEffect, on, onCleanup } from 'solid-js';
-import { useLunora } from './LunoraContext-C9SpKj54.mjs';
+import { useLunora } from './LunoraContext-C59PzHhN.mjs';
 
 const createQuery = (function_, args, options = {}) => {
   const client = useLunora();

package/dist/packem_shared/createStream-D9ONbGAw.mjs

@@ -0,0 +1,70 @@
+import { createSignal, createEffect, on, onCleanup } from 'solid-js';
+import { useLunora } from './LunoraContext-C59PzHhN.mjs';
+
+const createStream = (function_, args, options = {}) => {
+  const client = useLunora();
+  const [chunks, setChunks] = createSignal([]);
+  const [error, setError] = createSignal(void 0);
+  const [status, setStatus] = createSignal("idle");
+  const resolveArgs = typeof args === "function" ? args : () => args;
+  let cancelCurrent;
+  const cancel = () => {
+    cancelCurrent?.();
+  };
+  createEffect(on(resolveArgs, (currentArgs) => {
+    setChunks(() => []);
+    setError(() => void 0);
+    if (currentArgs === "skip") {
+      setStatus("idle");
+      return;
+    }
+    setStatus("streaming");
+    let active = true;
+    const iterable = client.stream(function_, currentArgs, {
+      maxBuffer: options.maxBuffer,
+      shardKey: options.shardKey
+    });
+    const cancelIterable = () => {
+      iterable.cancel();
+    };
+    cancelCurrent = cancelIterable;
+    (async () => {
+      try {
+        for await (const chunk of iterable) {
+          if (!active) {
+            return;
+          }
+          setChunks((previous) => [...previous, chunk]);
+        }
+        if (active) {
+          setStatus("complete");
+        }
+      } catch (streamError) {
+        if (!active) {
+          return;
+        }
+        setError(() => streamError instanceof Error ? streamError : new Error(String(streamError)));
+        setStatus("error");
+      }
+    })().catch(() => {
+    });
+    onCleanup(() => {
+      active = false;
+      cancelIterable();
+      if (cancelCurrent === cancelIterable) {
+        cancelCurrent = void 0;
+      }
+    });
+  }));
+  onCleanup(() => {
+    cancel();
+  });
+  return {
+    cancel,
+    chunks,
+    error,
+    status
+  };
+};
+
+export { createStream };

package/dist/packem_shared/{createSubscription-BM2fw8hw.mjs → createSubscription-D3HbChGe.mjs}

@@ -1,6 +1,7 @@
 import { createQuerySubscription } from '@lunora/client/query';
+import { LunoraError } from '@lunora/errors';
 import { createSignal, createEffect, on, onCleanup } from 'solid-js';
-import { useLunora } from './LunoraContext-C9SpKj54.mjs';
+import { useLunora } from './LunoraContext-C59PzHhN.mjs';
 
 const createSubscription = (function_, args, options = {}) => {
   const client = useLunora();
@@ -19,7 +20,8 @@ const createSubscription = (function_, args, options = {}) => {
         setError(() => void 0);
       },
       onError: (subscriptionError) => {
-        setError(() => new Error(subscriptionError.message));
+        const normalized = subscriptionError.code ? new LunoraError(subscriptionError.code, subscriptionError.message) : new Error(subscriptionError.message);
+        setError(() => normalized);
         setData(() => void 0);
       },
       onReset: () => {

package/dist/packem_shared/createVoiceAgent-hu59SaDl.mjs

@@ -0,0 +1,418 @@
+import { createSignal, onCleanup } from 'solid-js';
+import { useLunora } from './LunoraContext-C59PzHhN.mjs';
+import { resolveMaybe } from './createAgent-D7EZBeql.mjs';
+
+const TARGET_SAMPLE_RATE = 16e3;
+const blockRms = (samples) => {
+  if (samples.length === 0) {
+    return 0;
+  }
+  let sum = 0;
+  for (const sample of samples) {
+    sum += sample * sample;
+  }
+  return Math.sqrt(sum / samples.length);
+};
+const toPcm16 = (samples, inputSampleRate) => {
+  const ratio = inputSampleRate / TARGET_SAMPLE_RATE;
+  const outLength = ratio > 1 ? Math.floor(samples.length / ratio) : samples.length;
+  const buffer = new ArrayBuffer(outLength * 2);
+  const view = new DataView(buffer);
+  for (let index = 0; index < outLength; index += 1) {
+    const sample = samples[Math.floor(index * ratio)] ?? 0;
+    const clamped = Math.max(-1, Math.min(1, sample));
+    view.setInt16(index * 2, clamped < 0 ? clamped * 32768 : clamped * 32767, true);
+  }
+  return new Uint8Array(buffer);
+};
+const createBrowserMicrophone = async (config) => {
+  const media = globalThis;
+  const getUserMedia = media.navigator?.mediaDevices?.getUserMedia.bind(media.navigator.mediaDevices);
+  const AudioContextClass = media.AudioContext ?? media.webkitAudioContext;
+  if (!getUserMedia || !AudioContextClass) {
+    throw new Error("createVoiceAgent: microphone capture requires getUserMedia + AudioContext (no browser audio available)");
+  }
+  const stream = await getUserMedia({
+    audio: {
+      channelCount: 1,
+      echoCancellation: true,
+      noiseSuppression: true
+    }
+  });
+  const context = new AudioContextClass();
+  const source = context.createMediaStreamSource(stream);
+  const processor = context.createScriptProcessor(4096, 1, 1);
+  let muted = false;
+  let sawSpeech = false;
+  let silentFor = 0;
+  let loudChunks = 0;
+  processor.onaudioprocess = (event) => {
+    const samples = event.inputBuffer.getChannelData(0);
+    const rms = muted ? 0 : blockRms(samples);
+    config.onLevel(rms);
+    if (muted) {
+      return;
+    }
+    config.onAudio(toPcm16(samples, context.sampleRate));
+    if (config.isSpeaking()) {
+      loudChunks = rms >= config.interruptThreshold ? loudChunks + 1 : 0;
+      if (loudChunks >= config.interruptChunks) {
+        loudChunks = 0;
+        config.onInterrupt();
+      }
+      return;
+    }
+    loudChunks = 0;
+    const chunkMs = samples.length / context.sampleRate * 1e3;
+    if (rms >= config.silenceThreshold) {
+      sawSpeech = true;
+      silentFor = 0;
+      return;
+    }
+    if (sawSpeech) {
+      silentFor += chunkMs;
+      if (silentFor >= config.silenceDurationMs) {
+        sawSpeech = false;
+        silentFor = 0;
+        config.onSilence();
+      }
+    }
+  };
+  source.connect(processor);
+  processor.connect(context.destination);
+  return {
+    setMuted: (next) => {
+      muted = next;
+    },
+    stop: () => {
+      processor.disconnect();
+      source.disconnect();
+      for (const track of stream.getTracks()) {
+        track.stop();
+      }
+      void context.close();
+    }
+  };
+};
+const createBrowserSpeaker = () => {
+  const media = globalThis;
+  const AudioContextClass = media.AudioContext ?? media.webkitAudioContext;
+  if (!AudioContextClass) {
+    throw new Error("createVoiceAgent: audio playback requires AudioContext (no browser audio available)");
+  }
+  const context = new AudioContextClass();
+  const sources = /* @__PURE__ */ new Set();
+  let playHead = 0;
+  let chain = Promise.resolve();
+  let generation = 0;
+  const scheduleChunk = async (bytes, scheduledGeneration) => {
+    if (scheduledGeneration !== generation) {
+      return;
+    }
+    let decoded;
+    try {
+      decoded = await context.decodeAudioData(bytes.buffer);
+    } catch {
+      return;
+    }
+    if (scheduledGeneration !== generation) {
+      return;
+    }
+    const node = context.createBufferSource();
+    node.buffer = decoded;
+    node.connect(context.destination);
+    const startAt = Math.max(context.currentTime, playHead);
+    node.start(startAt);
+    playHead = startAt + decoded.duration;
+    sources.add(node);
+    node.onended = () => {
+      sources.delete(node);
+    };
+  };
+  const enqueue = (audio) => {
+    const bytes = Uint8Array.from(audio);
+    const scheduledGeneration = generation;
+    chain = chain.then(() => scheduleChunk(bytes, scheduledGeneration));
+  };
+  const interrupt = () => {
+    generation += 1;
+    for (const node of sources) {
+      try {
+        node.stop();
+      } catch {
+      }
+    }
+    sources.clear();
+    playHead = context.currentTime;
+  };
+  return {
+    enqueue,
+    interrupt,
+    stop: () => {
+      interrupt();
+      void context.close();
+    }
+  };
+};
+
+const WS_OPEN = 1;
+const DEFAULT_SILENCE_THRESHOLD = 0.01;
+const DEFAULT_SILENCE_DURATION_MS = 1200;
+const DEFAULT_INTERRUPT_THRESHOLD = 0.15;
+const DEFAULT_INTERRUPT_CHUNKS = 3;
+const deriveWebSocketUrl = (url) => {
+  if (url.startsWith("https://")) {
+    return `wss://${url.slice("https://".length)}`;
+  }
+  if (url.startsWith("http://")) {
+    return `ws://${url.slice("http://".length)}`;
+  }
+  return url;
+};
+const agentNameFromReference = (voice) => {
+  const reference = voice["__lunoraRef"];
+  const withoutNamespace = reference.startsWith("agents:") ? reference.slice("agents:".length) : reference;
+  return withoutNamespace.endsWith("Voice") ? withoutNamespace.slice(0, -"Voice".length) : withoutNamespace;
+};
+const voiceSocketUrl = (baseUrl, agent, threadKey) => {
+  const base = deriveWebSocketUrl(baseUrl);
+  const trimmed = base.endsWith("/") ? base.slice(0, -1) : base;
+  const search = new URLSearchParams({
+    threadKey
+  });
+  return `${trimmed}/_lunora/voice/${encodeURIComponent(agent)}?${search.toString()}`;
+};
+const createVoiceAgent = (options) => {
+  const {
+    createMicrophone = createBrowserMicrophone,
+    createSpeaker = createBrowserSpeaker,
+    createSocket,
+    interruptChunks = DEFAULT_INTERRUPT_CHUNKS,
+    interruptThreshold = DEFAULT_INTERRUPT_THRESHOLD,
+    silenceDurationMs = DEFAULT_SILENCE_DURATION_MS,
+    silenceThreshold = DEFAULT_SILENCE_THRESHOLD,
+    threadKey,
+    voice
+  } = options;
+  const client = useLunora();
+  const [status, setStatus] = createSignal("idle");
+  const [connected, setConnected] = createSignal(false);
+  const [transcript, setTranscript] = createSignal("");
+  const [interimTranscript, setInterimTranscript] = createSignal("");
+  const [audioLevel, setAudioLevel] = createSignal(0);
+  const [isMuted, setIsMuted] = createSignal(false);
+  const [error, setError] = createSignal(void 0);
+  let current;
+  let starting = false;
+  const sendFrame = (frame) => {
+    const socket = current?.socket;
+    if (socket?.readyState === WS_OPEN) {
+      socket.send(JSON.stringify(frame));
+      return true;
+    }
+    return false;
+  };
+  const teardown = () => {
+    const connection = current;
+    current = void 0;
+    if (connection) {
+      connection.microphone?.stop();
+      connection.speaker?.stop();
+      try {
+        connection.socket.close();
+      } catch {
+      }
+    }
+    starting = false;
+    setConnected(false);
+    setStatus("idle");
+    setAudioLevel(0);
+  };
+  const endCall = () => {
+    teardown();
+  };
+  const handleServerFrame = (frame) => {
+    const connection = current;
+    switch (frame.type) {
+      case "assistant_delta": {
+        if (connection) {
+          connection.speaking = true;
+        }
+        setStatus("speaking");
+        setInterimTranscript((previous) => previous + frame.text);
+        break;
+      }
+      case "assistant_done": {
+        if (connection) {
+          connection.speaking = false;
+        }
+        setInterimTranscript(frame.text);
+        setStatus("listening");
+        break;
+      }
+      case "error": {
+        if (connection) {
+          connection.speaking = false;
+        }
+        setError(new Error(frame.message));
+        setStatus("listening");
+        break;
+      }
+      case "interrupted": {
+        if (connection) {
+          connection.speaking = false;
+          connection.suppressAudio = false;
+        }
+        connection?.speaker?.interrupt();
+        setStatus("listening");
+        break;
+      }
+      case "ready": {
+        if (connection) {
+          connection.audioFormat = frame.audioFormat;
+          connection.suppressAudio = false;
+        }
+        setConnected(true);
+        setStatus("listening");
+        break;
+      }
+      case "user_transcript": {
+        if (connection) {
+          connection.suppressAudio = false;
+        }
+        setTranscript(frame.text);
+        setInterimTranscript("");
+        setStatus("thinking");
+        break;
+      }
+    }
+  };
+  const handleAudioChunk = (audio) => {
+    const connection = current;
+    if (!connection || connection.suppressAudio) {
+      return;
+    }
+    connection.speaker ??= createSpeaker({
+      audioFormat: connection.audioFormat
+    });
+    connection.speaking = true;
+    setStatus("speaking");
+    connection.speaker.enqueue(audio);
+  };
+  const startCall = async () => {
+    if (current || starting) {
+      return;
+    }
+    starting = true;
+    setError(void 0);
+    setTranscript("");
+    setInterimTranscript("");
+    try {
+      const url = voiceSocketUrl(client.url, agentNameFromReference(voice), resolveMaybe(threadKey));
+      const openSocket = createSocket ?? ((target) => new globalThis.WebSocket(target));
+      const socket = openSocket(url);
+      socket.binaryType = "arraybuffer";
+      const connection = {
+        audioFormat: "mp3",
+        microphone: void 0,
+        socket,
+        speaker: void 0,
+        speaking: false,
+        suppressAudio: false
+      };
+      current = connection;
+      socket.onmessage = (event) => {
+        if (typeof event.data === "string") {
+          try {
+            handleServerFrame(JSON.parse(event.data));
+          } catch {
+          }
+          return;
+        }
+        handleAudioChunk(new Uint8Array(event.data));
+      };
+      socket.onerror = () => {
+        setError(new Error("createVoiceAgent: voice socket error"));
+      };
+      socket.onclose = () => {
+        if (current === connection) {
+          teardown();
+        }
+      };
+      const microphone = await createMicrophone({
+        interruptChunks,
+        interruptThreshold,
+        isSpeaking: () => current?.speaking ?? false,
+        onAudio: (pcm) => {
+          if (socket.readyState === WS_OPEN) {
+            socket.send(pcm);
+          }
+        },
+        onInterrupt: () => {
+          sendFrame({
+            type: "interrupt"
+          });
+          current?.speaker?.interrupt();
+          if (current) {
+            current.speaking = false;
+            current.suppressAudio = true;
+          }
+          setStatus("listening");
+        },
+        onLevel: (rms) => {
+          setAudioLevel(rms);
+        },
+        onSilence: () => {
+          sendFrame({
+            type: "commit"
+          });
+          setStatus("thinking");
+        },
+        silenceDurationMs,
+        silenceThreshold
+      });
+      if (current === connection) {
+        connection.microphone = microphone;
+        setIsMuted(false);
+        setStatus("listening");
+      } else {
+        microphone.stop();
+      }
+    } catch (error_) {
+      setError(error_ instanceof Error ? error_ : new Error(String(error_)));
+      teardown();
+    } finally {
+      starting = false;
+    }
+  };
+  const toggleMute = () => {
+    const next = !isMuted();
+    current?.microphone?.setMuted(next);
+    setIsMuted(next);
+    return next;
+  };
+  const sendText = (text) => {
+    if (sendFrame({
+      text,
+      type: "text"
+    })) {
+      setStatus("thinking");
+    }
+  };
+  onCleanup(teardown);
+  return {
+    audioLevel,
+    connected,
+    endCall,
+    error,
+    interimTranscript,
+    isMuted,
+    sendText,
+    startCall,
+    status,
+    toggleMute,
+    transcript
+  };
+};
+
+export { createVoiceAgent };

package/dist/packem_shared/{hydratePreloaded-CaT1kDBH.mjs → hydratePreloaded-CWny5-2J.mjs}

@@ -1,5 +1,5 @@
 import { createSignal, createEffect, onCleanup } from 'solid-js';
-import { useLunora } from './LunoraContext-C9SpKj54.mjs';
+import { useLunora } from './LunoraContext-C59PzHhN.mjs';
 
 const hydratePreloaded = (preloaded) => {
   const client = useLunora();

package/dist/packem_shared/stable-key-DePnevIy.mjs

@@ -0,0 +1,38 @@
+const compareKeys = (a, b) => {
+  if (a < b) {
+    return -1;
+  }
+  return a > b ? 1 : 0;
+};
+const stableStringify = (value) => {
+  if (value === void 0) {
+    return "null";
+  }
+  if (typeof value === "bigint") {
+    throw new TypeError("stableStringify: cannot use a bigint in a stable JSON cache key — pass it as a string, or use stableWireKey");
+  }
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== null && proto !== Object.prototype) {
+    const name = value.constructor?.name ?? "value";
+    throw new TypeError(`stableStringify: cannot use a ${name} in a stable JSON cache key — only plain objects, arrays, and JSON primitives are supported (wire-typed values key via stableWireKey)`);
+  }
+  const record = value;
+  const keys = Object.keys(record).toSorted(compareKeys);
+  const parts = [];
+  for (const key of keys) {
+    const raw = record[key];
+    if (raw === void 0) {
+      continue;
+    }
+    parts.push(`${JSON.stringify(key)}:${stableStringify(raw)}`);
+  }
+  return `{${parts.join(",")}}`;
+};
+
+export { stableStringify as s };

package/dist/upload.d.mts

@@ -0,0 +1,2 @@
+export { RestrictionError, UploadControl, UploadError, type UploadMethod, type UploadRestrictions, type UploadResult } from '@visulima/storage-client';
+export { type CreateChunkedRestUploadOptions, type CreateChunkedRestUploadReturn, type CreateFileInputOptions, type CreateFileInputReturn, type CreateMultipartUploadOptions, type CreateMultipartUploadReturn, type CreatePasteUploadOptions, type CreatePasteUploadReturn, type CreateTusUploadOptions, type CreateTusUploadReturn, type CreateUploadOptions, type CreateUploadReturn, createChunkedRestUpload, createFileInput, createMultipartUpload, createPasteUpload, createTusUpload, createUpload } from '@visulima/storage-client/solid';

package/dist/upload.d.ts

@@ -0,0 +1,2 @@
+export { RestrictionError, UploadControl, UploadError, type UploadMethod, type UploadRestrictions, type UploadResult } from '@visulima/storage-client';
+export { type CreateChunkedRestUploadOptions, type CreateChunkedRestUploadReturn, type CreateFileInputOptions, type CreateFileInputReturn, type CreateMultipartUploadOptions, type CreateMultipartUploadReturn, type CreatePasteUploadOptions, type CreatePasteUploadReturn, type CreateTusUploadOptions, type CreateTusUploadReturn, type CreateUploadOptions, type CreateUploadReturn, createChunkedRestUpload, createFileInput, createMultipartUpload, createPasteUpload, createTusUpload, createUpload } from '@visulima/storage-client/solid';

package/dist/upload.mjs

@@ -0,0 +1,2 @@
+export { RestrictionError, UploadControl, UploadError } from '@visulima/storage-client';
+export { createChunkedRestUpload, createFileInput, createMultipartUpload, createPasteUpload, createTusUpload, createUpload } from '@visulima/storage-client/solid';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/solid",
-  "version": "1.0.0-alpha.3",
+  "version": "1.0.0-alpha.30",
   "description": "SolidJS adapter for Lunora — live queries, optimistic mutations, and reactive loaders",
   "keywords": [
     "cloudflare",
@@ -25,7 +25,7 @@
     "directory": "packages/solid"
   },
   "files": [
-    "dist",
+    "./dist",
     "README.md",
     "LICENSE.md",
     "__assets__"
@@ -44,14 +44,20 @@
       "types": "./dist/server.d.ts",
       "import": "./dist/server.mjs"
     },
+    "./upload": {
+      "types": "./dist/upload.d.ts",
+      "import": "./dist/upload.mjs"
+    },
     "./package.json": "./package.json"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@lunora/client": "1.0.0-alpha.2",
-    "@lunora/ratelimit": "1.0.0-alpha.2"
+    "@lunora/client": "1.0.0-alpha.28",
+    "@lunora/errors": "1.0.0-alpha.8",
+    "@lunora/ratelimit": "1.0.0-alpha.10",
+    "@visulima/storage-client": "1.0.0"
   },
   "peerDependencies": {
     "solid-js": "^1.9.0"