@aethervtt/shard-platform-web 0.1.0 → 0.2.1

package/dist/index.d.ts

@@ -9,6 +9,7 @@ export interface WebPlatformOptions {
 }
 export declare function createWebPlatform(options?: WebPlatformOptions): Platform;
 export { createWebAudioBackend, type WebAudioBackend } from './audio.js';
+export { type AudioRenderPlan, audioBufferWav, measureAudioBuffer, renderAudioPreview, } from './audio-preview.js';
 export { createDomInputSource, type DomInputOptions } from './input.js';
 export { createWebPerformance } from './performance.js';
 export { createIndexedDbStorage } from './storage.js';

package/dist/index.js

@@ -21,9 +21,22 @@ function createWebPlatform(options = {}) {
     return res;
   };
   const fs = {
+    resolveUrl: (path) => new URL(path, baseUrl).href,
     writable: false,
     readText: async (path) => (await fetchOk(path)).text(),
     readBytes: async (path) => new Uint8Array(await (await fetchOk(path)).arrayBuffer()),
+    readRange: async (path, offset, length) => {
+      const res = await fetch(new URL(path, baseUrl), {
+        headers: { Range: `bytes=${offset}-${offset + length - 1}` }
+      });
+      if (!res.ok) {
+        throw new ShardError("platform/fs-not-found", `Failed to fetch "${path}" (${res.status})`, {
+          path
+        });
+      }
+      const bytes = new Uint8Array(await res.arrayBuffer());
+      return res.status === 206 ? bytes : bytes.subarray(offset, offset + length);
+    },
     writeText: async (path) => readOnly(path),
     writeBytes: async (path) => readOnly(path),
     exists: async (path) => (await fetch(new URL(path, baseUrl), { method: "HEAD" })).ok
@@ -51,15 +64,23 @@ function createWebPlatform(options = {}) {
   };
 }
 import { createWebAudioBackend as createWebAudioBackend2 } from "./audio.js";
+import {
+  audioBufferWav,
+  measureAudioBuffer,
+  renderAudioPreview
+} from "./audio-preview.js";
 import { createDomInputSource } from "./input.js";
 import { createWebPerformance as createWebPerformance2 } from "./performance.js";
 import { createIndexedDbStorage as createIndexedDbStorage2 } from "./storage.js";
 import { createWebWorkers as createWebWorkers2 } from "./workers.js";
 export {
+  audioBufferWav,
   createDomInputSource,
   createIndexedDbStorage2 as createIndexedDbStorage,
   createWebAudioBackend2 as createWebAudioBackend,
   createWebPerformance2 as createWebPerformance,
   createWebPlatform,
-  createWebWorkers2 as createWebWorkers
+  createWebWorkers2 as createWebWorkers,
+  measureAudioBuffer,
+  renderAudioPreview
 };

package/dist/performance.js

@@ -28,10 +28,75 @@ function createWebPerformance() {
         return () => void listeners.delete(listener);
       }
     },
-    ...timing && { downloads }
+    ...timing && { downloads },
+    heap,
+    startSampler,
+    measure
   };
   return shared;
 }
+const MEMORY_EVERY_MS = 5e3;
+let measured;
+let measuring = false;
+let measuredAt = Number.NEGATIVE_INFINITY;
+function heap() {
+  const page = performance;
+  if (globalThis.crossOriginIsolated && page.measureUserAgentSpecificMemory) {
+    const now = performance.now();
+    if (!measuring && now - measuredAt >= MEMORY_EVERY_MS) {
+      measuring = true;
+      measuredAt = now;
+      page.measureUserAgentSpecificMemory().then((r) => {
+        measured = { usedBytes: r.bytes, source: "measureUserAgentSpecificMemory" };
+      }).catch(() => {
+      }).finally(() => {
+        measuring = false;
+      });
+    }
+    if (measured) return measured;
+  }
+  const memory = page.memory;
+  if (!memory) return void 0;
+  return {
+    usedBytes: memory.usedJSHeapSize,
+    totalBytes: memory.totalJSHeapSize,
+    limitBytes: memory.jsHeapSizeLimit,
+    source: "performance.memory"
+  };
+}
+const SAMPLE_INTERVAL_MS = 1;
+async function startSampler() {
+  const Ctor = globalThis.Profiler;
+  if (!Ctor) return void 0;
+  let profiler;
+  try {
+    profiler = new Ctor({ sampleInterval: SAMPLE_INTERVAL_MS, maxBufferSize: 1e5 });
+  } catch {
+    return void 0;
+  }
+  return {
+    stop: async () => {
+      const trace = await profiler.stop();
+      const { hottestFromSelfProfile, samplesFromSelfProfile } = await import("@aethervtt/shard-core/capture");
+      return {
+        hottest: hottestFromSelfProfile(trace, SAMPLE_INTERVAL_MS),
+        samples: samplesFromSelfProfile(trace, SAMPLE_INTERVAL_MS)
+      };
+    }
+  };
+}
+function measure(name, track, start, ms) {
+  try {
+    performance.measure(name, {
+      start,
+      end: start + ms,
+      detail: {
+        devtools: { dataType: "track-entry", track: `shard ${track}`, trackGroup: "Shard" }
+      }
+    });
+  } catch {
+  }
+}
 function downloads() {
   const result = { transferred: 0, decoded: 0 };
   const add = (entry) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aethervtt/shard-platform-web",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "license": "MIT",
   "type": "module",
   "sideEffects": false,
@@ -16,8 +16,8 @@
     "README.md"
   ],
   "dependencies": {
-    "@aethervtt/shard-core": "0.1.0",
-    "@aethervtt/shard-platform": "0.1.0"
+    "@aethervtt/shard-core": "0.2.1",
+    "@aethervtt/shard-platform": "0.2.1"
   },
   "repository": {
     "type": "git",
@@ -29,6 +29,6 @@
     "provenance": true
   },
   "shard": {
-    "buildSha": "8e14c9896f82a3554b156f1ffdd68f2cc3e7d78a"
+    "buildSha": "772eb0d2b8a5fc499105708f4ae92c58788cc9ea"
   }
 }