lecodes-sdk 2.2.10 → 2.2.11

package/package.json

@@ -45,7 +45,7 @@
     "marcidb-embedded": "^0.15.0",
     "sharp": "^0.35.2"
   },
-  "version": "2.2.10",
+  "version": "2.2.11",
   "files": [
     "src",
     "dist",

package/src/bridges/media.d.ts

@@ -18,7 +18,9 @@ import type { f32, f64, i32 } from "./types"
 declare global {
   /** @host media @optional */
   var _creatorMedia: {
-    /** A player for `src` as an owned Handle (null = the host failed to create one). @custom */
+    /** A player for `src` as an owned Handle (null = the host failed to create one). `src` is a url
+     *  or `"id:<bufferId>"` (a host buffer: a local asset, a File, a FetchResponse), which the host
+     *  resolves. @custom */
     createAudio(src: string): Handle | null
     /** @custom */
     createVideo(src: string): Handle | null

package/src/canvas/Canvas.ts

@@ -115,14 +115,14 @@ export class Canvas extends Recorder {
   }
 
   /** Decode an image source into a standalone `Bitmap` you can blit with `drawImage()` — either an
-   *  `SvgSource(...)` (drawn by the core, painted by the host) or a `FetchResponse` holding already-fetched
-   *  image bytes (decoded; an SVG file is detected). This is async because the web host decodes with the
-   *  browser; `await` it ONCE, then `drawImage(bitmap, …)` is synchronous and the Bitmap is reusable. The
-   *  returned Bitmap owns a native surface at the image's natural pixel size (`pixelRatio` 1), freed
-   *  once nothing references the Bitmap (`destroy()` frees it early). Typical use:
+   *  `SvgSource(...)` (drawn by the core, painted by the host) or a `FetchResponse` / `File` holding
+   *  already-fetched image bytes (decoded; an SVG file is detected). This is async because the web host
+   *  decodes with the browser; `await` it ONCE, then `drawImage(bitmap, …)` is synchronous and the Bitmap
+   *  is reusable. The returned Bitmap owns a native surface at the image's natural pixel size
+   *  (`pixelRatio` 1), freed once nothing references the Bitmap (`destroy()` frees it early). Typical use:
    *    const logo = await canvas.loadImage(SvgSource(svg))   // or: await fetch(url) → the response
    *    canvas.drawImage(logo, 0, 0)                          // sync, blit as often as you like */
-  loadImage(source: SvgSourceValue | FetchResponse): Promise<Bitmap> {
+  loadImage(source: SvgSourceValue | FetchResponse | File): Promise<Bitmap> {
     // Discriminate without touching FetchResponse internals: only an SvgSource carries `.svg`.
     const isSvg = typeof (source as SvgSourceValue).svg === "string"
     const svg = isSvg ? (source as SvgSourceValue).svg : ""

package/src/runtime/media.ts

@@ -7,10 +7,14 @@
 // then; a paused player you stop referencing is released at once. There is nothing to dispose. The
 // end-of-playback report comes by id through ONE emitter per world; a playing player is pinned so
 // the report finds it.
+//
+// `src` is a url, or a `File` / `FetchResponse`: those play from the host's buffer store
+// (`"id:<bufferId>"`, the whole bytes in memory, no streaming).
 
 import { Emitter } from "../core/events"
 import { Pins } from "../core/pins"
 import { Texture } from "../gl/Texture"
+import type { File, FetchResponse } from "./fetch"
 
 type MediaEvents = {
   /** Fired at each loop boundary while `loop` is true. */
@@ -30,6 +34,9 @@ const ensureEmitter = (): void => {
   emitterInstalled = true
   m.setEmitter((id) => { players.get(id)?._finished() })
 }
+/** The wire spelling of a source: a url as is, a buffer (File / FetchResponse) as "id:<bufferId>". */
+const wireSrc = (src?: string | File | FetchResponse): string =>
+  src == null ? "" : typeof src === "string" ? src : "id:" + (src as any)._h.id
 
 abstract class MediaPlayer extends Emitter<MediaEvents> {
   /** @internal The player's owned handle (`_h.id` = the host player id; -1 = no host player). */
@@ -92,18 +99,18 @@ abstract class MediaPlayer extends Emitter<MediaEvents> {
 }
 
 export class AudioPlayer extends MediaPlayer {
-  constructor(src?: string) {
+  constructor(src?: string | File | FetchResponse) {
     super()
-    this._src = src ?? ""
+    this._src = wireSrc(src)
     ensureEmitter()
     this._h = media()?.createAudio(this._src) ?? { id: -1 }
   }
 }
 
 export class VideoPlayer extends MediaPlayer {
-  constructor(src?: string) {
+  constructor(src?: string | File | FetchResponse) {
     super()
-    this._src = src ?? ""
+    this._src = wireSrc(src)
     ensureEmitter()
     this._h = media()?.createVideo(this._src) ?? { id: -1 }
   }

package/src/version.ts

@@ -4,7 +4,7 @@
 // same manifest). Its MAJOR is the bundle ↔ runtime contract: a bundle's `// sdk:` header line
 // and a host's embedded version must agree on the major for the host to run the bundle; minor
 // and patch never gate anything (features are detected, never versioned).
-export const SDK_VERSION = "2.2.10"
+export const SDK_VERSION = "2.2.11"
 
 /** The major of a semver string, or null when it is not one. */
 export const sdkMajor = (version: string | null | undefined): number | null => {