@cimplify/sdk 0.108.0 → 0.110.2

package/dist/interactives-record.d.mts

@@ -0,0 +1,112 @@
+import { g as CtxAssets, h as ProgressiveListener, i as ProgressiveLoad, e as PlatformEngineRuntime } from './local-D8_I6UeL.mjs';
+import { A as AssetSink, I as IndexedAsset, C as ChunkChannel, a as ChunkFailureName, b as ChunkPriority, F as FrameTouch, c as FrameTouchKind, M as MilestoneName, d as GuestProfile, G as GuestRuntime } from './guest-DrsA00XD.mjs';
+import { N as NetworkHint } from './network-ZXLD7l1b.mjs';
+import './link-BUTqGmyi.mjs';
+import './schema-BrWxzKp6.mjs';
+import './ui-DwHicuFv.mjs';
+import './vars-Dc_PrhBK.mjs';
+
+type JoinedModules = (sha256: string, parts: readonly string[]) => Promise<WebAssembly.Module>;
+type WasmCompiler = (bytes: Uint8Array<ArrayBuffer>) => Promise<WebAssembly.Module>;
+declare class PackageAssets implements CtxAssets, AssetSink {
+    private readonly joinedSource;
+    private readonly compiler;
+    private readonly arrived;
+    private readonly tiered;
+    private readonly waiting;
+    private readonly paths;
+    private readonly modules;
+    private readonly lazyDigests;
+    private readonly prefetching;
+    private readonly prefetched;
+    private readonly cancelled;
+    private readonly networkListeners;
+    private readonly parted;
+    private readonly assetParts;
+    private readonly progressiveAssets;
+    private channel;
+    private hint;
+    private catalogPending;
+    private catalogDone;
+    constructor(joinedSource?: JoinedModules | null, compiler?: WasmCompiler | null);
+    joined(sha256: string, parts: readonly string[]): Promise<WebAssembly.Module> | null;
+    warm(parts: readonly string[], compile: (binary: {
+        parts: readonly string[];
+        bytes: number;
+    }) => Promise<WebAssembly.Module>): Promise<WebAssembly.Module> | null;
+    binary(parts: readonly string[]): {
+        parts: readonly string[];
+        bytes: number;
+    } | null;
+    module(parts: readonly string[]): Promise<WebAssembly.Module> | null;
+    private joinTaken;
+    catalog(assets: readonly IndexedAsset[]): void;
+    awaitCatalog(): void;
+    catalogued(): void;
+    /** An asset the follow index will catalog: not known yet, and not a chunk digest. */
+    private uncatalogued;
+    has(asset: string): boolean;
+    resolve(asset: string): string;
+    accept(digest: string, payload: Uint8Array): void;
+    connect(channel: ChunkChannel): void;
+    network(hint: NetworkHint): void;
+    networkHint(): NetworkHint | null;
+    onNetwork(listener: (hint: NetworkHint) => void): () => void;
+    fail(digest: string, reason: ChunkFailureName): void;
+    prefetch(asset: string, priority?: ChunkPriority): boolean;
+    cancelPrefetch(asset: string): boolean;
+    resident(asset: string): boolean;
+    pending(asset: string): boolean;
+    lazy(asset: string): boolean;
+    requests(): boolean;
+    isProgressive(asset: string): boolean;
+    progressive(asset: string, listener?: ProgressiveListener | null, priority?: ChunkPriority, refine?: ChunkPriority): ProgressiveLoad;
+    private feedProgressive;
+    take(asset: string, priority?: ChunkPriority, stall?: boolean): Promise<Uint8Array>;
+    private takeStored;
+    release(asset: string): void;
+}
+
+declare const RECORD_SURFACE: {
+    readonly width: 390;
+    readonly height: 844;
+    readonly pixel_ratio: 3;
+};
+interface WorkerScope {
+    postMessage(message: unknown, transfer: Transferable[]): void;
+    addEventListener(type: "message", listener: (event: MessageEvent<ArrayBuffer>) => void): void;
+    setTimeout(handler: () => void, delay: number): unknown;
+}
+type FrameListener = (time_ms: number) => void;
+declare class SteppedClock {
+    private readonly send;
+    private readonly defer;
+    private frame;
+    private nextHandle;
+    private readonly callbacks;
+    readonly surfaces: Set<FrameListener>;
+    private touches;
+    private outstanding;
+    heap: () => number;
+    constructor(send: (bytes: Uint8Array, length: number) => void, defer: (work: () => void) => void);
+    get frames(): number;
+    requestAnimationFrame(callback: FrameListener): number;
+    cancelAnimationFrame(handle: number): void;
+    touch<T>(path: string, kind: FrameTouchKind, priority: number, pending: Promise<T> | null): void;
+    step(): void;
+    readonly pipelines: PipelineLog;
+}
+declare class PipelineLog {
+    private exports;
+    private memory;
+    private render;
+    private pointer;
+    private readonly seen;
+    attach(runtime: PlatformEngineRuntime, render: number): void;
+    collect(out: FrameTouch[]): void;
+}
+declare function recordingAssets(assets: PackageAssets, clock: SteppedClock): CtxAssets;
+declare function recordProfile(clock: SteppedClock, assets: PackageAssets, core: Promise<WebAssembly.Module>, mark: (name: MilestoneName) => void, heapPages?: () => number): GuestProfile;
+declare function startRecordGuest(scope: WorkerScope & Record<string, unknown>): GuestRuntime;
+
+export { PipelineLog, RECORD_SURFACE, SteppedClock, recordProfile, recordingAssets, startRecordGuest };

package/dist/interactives-record.d.ts

@@ -0,0 +1,112 @@
+import { g as CtxAssets, h as ProgressiveListener, i as ProgressiveLoad, e as PlatformEngineRuntime } from './local-VZkqsCzR.js';
+import { A as AssetSink, I as IndexedAsset, C as ChunkChannel, a as ChunkFailureName, b as ChunkPriority, F as FrameTouch, c as FrameTouchKind, M as MilestoneName, d as GuestProfile, G as GuestRuntime } from './guest-wIdfoT05.js';
+import { N as NetworkHint } from './network-ZXLD7l1b.js';
+import './link-BUTqGmyi.js';
+import './schema-BrWxzKp6.js';
+import './ui-hi7S2YcH.js';
+import './vars-Dc_PrhBK.js';
+
+type JoinedModules = (sha256: string, parts: readonly string[]) => Promise<WebAssembly.Module>;
+type WasmCompiler = (bytes: Uint8Array<ArrayBuffer>) => Promise<WebAssembly.Module>;
+declare class PackageAssets implements CtxAssets, AssetSink {
+    private readonly joinedSource;
+    private readonly compiler;
+    private readonly arrived;
+    private readonly tiered;
+    private readonly waiting;
+    private readonly paths;
+    private readonly modules;
+    private readonly lazyDigests;
+    private readonly prefetching;
+    private readonly prefetched;
+    private readonly cancelled;
+    private readonly networkListeners;
+    private readonly parted;
+    private readonly assetParts;
+    private readonly progressiveAssets;
+    private channel;
+    private hint;
+    private catalogPending;
+    private catalogDone;
+    constructor(joinedSource?: JoinedModules | null, compiler?: WasmCompiler | null);
+    joined(sha256: string, parts: readonly string[]): Promise<WebAssembly.Module> | null;
+    warm(parts: readonly string[], compile: (binary: {
+        parts: readonly string[];
+        bytes: number;
+    }) => Promise<WebAssembly.Module>): Promise<WebAssembly.Module> | null;
+    binary(parts: readonly string[]): {
+        parts: readonly string[];
+        bytes: number;
+    } | null;
+    module(parts: readonly string[]): Promise<WebAssembly.Module> | null;
+    private joinTaken;
+    catalog(assets: readonly IndexedAsset[]): void;
+    awaitCatalog(): void;
+    catalogued(): void;
+    /** An asset the follow index will catalog: not known yet, and not a chunk digest. */
+    private uncatalogued;
+    has(asset: string): boolean;
+    resolve(asset: string): string;
+    accept(digest: string, payload: Uint8Array): void;
+    connect(channel: ChunkChannel): void;
+    network(hint: NetworkHint): void;
+    networkHint(): NetworkHint | null;
+    onNetwork(listener: (hint: NetworkHint) => void): () => void;
+    fail(digest: string, reason: ChunkFailureName): void;
+    prefetch(asset: string, priority?: ChunkPriority): boolean;
+    cancelPrefetch(asset: string): boolean;
+    resident(asset: string): boolean;
+    pending(asset: string): boolean;
+    lazy(asset: string): boolean;
+    requests(): boolean;
+    isProgressive(asset: string): boolean;
+    progressive(asset: string, listener?: ProgressiveListener | null, priority?: ChunkPriority, refine?: ChunkPriority): ProgressiveLoad;
+    private feedProgressive;
+    take(asset: string, priority?: ChunkPriority, stall?: boolean): Promise<Uint8Array>;
+    private takeStored;
+    release(asset: string): void;
+}
+
+declare const RECORD_SURFACE: {
+    readonly width: 390;
+    readonly height: 844;
+    readonly pixel_ratio: 3;
+};
+interface WorkerScope {
+    postMessage(message: unknown, transfer: Transferable[]): void;
+    addEventListener(type: "message", listener: (event: MessageEvent<ArrayBuffer>) => void): void;
+    setTimeout(handler: () => void, delay: number): unknown;
+}
+type FrameListener = (time_ms: number) => void;
+declare class SteppedClock {
+    private readonly send;
+    private readonly defer;
+    private frame;
+    private nextHandle;
+    private readonly callbacks;
+    readonly surfaces: Set<FrameListener>;
+    private touches;
+    private outstanding;
+    heap: () => number;
+    constructor(send: (bytes: Uint8Array, length: number) => void, defer: (work: () => void) => void);
+    get frames(): number;
+    requestAnimationFrame(callback: FrameListener): number;
+    cancelAnimationFrame(handle: number): void;
+    touch<T>(path: string, kind: FrameTouchKind, priority: number, pending: Promise<T> | null): void;
+    step(): void;
+    readonly pipelines: PipelineLog;
+}
+declare class PipelineLog {
+    private exports;
+    private memory;
+    private render;
+    private pointer;
+    private readonly seen;
+    attach(runtime: PlatformEngineRuntime, render: number): void;
+    collect(out: FrameTouch[]): void;
+}
+declare function recordingAssets(assets: PackageAssets, clock: SteppedClock): CtxAssets;
+declare function recordProfile(clock: SteppedClock, assets: PackageAssets, core: Promise<WebAssembly.Module>, mark: (name: MilestoneName) => void, heapPages?: () => number): GuestProfile;
+declare function startRecordGuest(scope: WorkerScope & Record<string, unknown>): GuestRuntime;
+
+export { PipelineLog, RECORD_SURFACE, SteppedClock, recordProfile, recordingAssets, startRecordGuest };

package/dist/interactives-record.js

@@ -0,0 +1,302 @@
+'use strict';
+
+var chunkAYJPHKYV_js = require('./chunk-AYJPHKYV.js');
+var chunkO2ICABUD_js = require('./chunk-O2ICABUD.js');
+var chunkNZTKLY2W_js = require('./chunk-NZTKLY2W.js');
+require('./chunk-FXVJ2HFU.js');
+require('./chunk-J2U6PJSO.js');
+require('./chunk-KMKWGXMK.js');
+var chunk2O2CG465_js = require('./chunk-2O2CG465.js');
+var chunk6WUBSMTX_js = require('./chunk-6WUBSMTX.js');
+require('./chunk-ZXREOYOW.js');
+require('./chunk-GDZT5LZ5.js');
+var chunkZMIL4ZOA_js = require('./chunk-ZMIL4ZOA.js');
+require('./chunk-QQABGCMM.js');
+require('./chunk-XK6UDWJS.js');
+require('./chunk-T7LOXGYX.js');
+require('./chunk-E2QPPH7I.js');
+require('./chunk-OLWFPDBK.js');
+require('./chunk-5SXDH3Y7.js');
+require('./chunk-VRBDAS5I.js');
+require('./chunk-I5FOHCLH.js');
+require('./chunk-TJI3K6RP.js');
+require('./chunk-ZJBRUH6V.js');
+require('./chunk-66QP3SMN.js');
+require('./chunk-WWKMOA76.js');
+var chunk4ZDR72SG_js = require('./chunk-4ZDR72SG.js');
+require('./chunk-T6Z2EXYL.js');
+require('./chunk-PDOELNNQ.js');
+require('./chunk-J2KZXIU3.js');
+require('./chunk-PTRNO5UD.js');
+var chunk6SWKWCMS_js = require('./chunk-6SWKWCMS.js');
+require('./chunk-2V7IL4HC.js');
+require('./chunk-JGBCIKJV.js');
+
+// src/interactives/runtime/record-entry.ts
+var RECORD_SURFACE = { width: 390, height: 844, pixel_ratio: 3 }, ED25519 = "Ed25519", NO_UNSUBSCRIBE = () => {
+}, SteppedClock = class {
+  constructor(send, defer) {
+    this.send = send;
+    this.defer = defer;
+    this.frame = 0;
+    this.nextHandle = 1;
+    this.callbacks = /* @__PURE__ */ new Map();
+    this.surfaces = /* @__PURE__ */ new Set();
+    this.touches = [];
+    this.outstanding = 0;
+    this.heap = () => 0;
+    this.pipelines = new PipelineLog();
+  }
+  get frames() {
+    return this.frame;
+  }
+  requestAnimationFrame(callback) {
+    let handle = this.nextHandle++;
+    return this.callbacks.set(handle, callback), handle;
+  }
+  cancelAnimationFrame(handle) {
+    this.callbacks.delete(handle);
+  }
+  touch(path, kind, priority, pending) {
+    if (this.touches.push({ path, kind, priority }), pending === null) return;
+    this.outstanding++;
+    let settle = () => {
+      this.outstanding--;
+    };
+    pending.then(settle, settle);
+  }
+  step() {
+    let time = this.frame * chunkAYJPHKYV_js.FIXED_STEP_MS, due = [...this.callbacks.values()];
+    this.callbacks.clear();
+    for (let callback of due) callback(time);
+    for (let surface of this.surfaces) surface(time);
+    let frame = this.frame++;
+    this.defer(() => {
+      this.pipelines.collect(this.touches);
+      let bytes = chunk4ZDR72SG_js.encodeFrameMark({ frame, outstanding: this.outstanding, touches: this.touches, heap: this.heap() });
+      this.touches = [], this.send(bytes, bytes.length);
+    });
+  }
+}, PIPELINE_CAPACITY = 1024, PIPELINE_KEY_BYTES = 8, PIPELINE_KEY_HEX = 16, HEX = 16, RECORDING = 1, NO_POINTER = 0, PipelineLog = class {
+  constructor() {
+    this.exports = null;
+    this.memory = null;
+    this.render = 0;
+    this.pointer = (0);
+    this.seen = /* @__PURE__ */ new Set();
+  }
+  attach(runtime, render) {
+    let exports = runtime.exports, record = exports.engine_render_record_pipelines, alloc = exports.engine_alloc;
+    typeof record != "function" || typeof alloc != "function" || record(render, (1)) < 0 || (this.pointer = alloc((1024) * (8), (8)), this.pointer !== (0) && (this.exports = exports, this.memory = runtime.memory, this.render = render));
+  }
+  collect(out) {
+    let exports = this.exports, memory = this.memory;
+    if (exports === null || memory === null) return;
+    let count = exports.engine_render_pipelines(this.render, this.pointer, (1024));
+    if (count <= 0) return;
+    let keys = new BigUint64Array(memory.buffer, this.pointer, Math.min(count, (1024)));
+    for (let key of keys)
+      this.seen.has(key) || (this.seen.add(key), out.push({ path: chunk4ZDR72SG_js.PIPELINE_TOUCH_PREFIX + key.toString((16)).padStart((16), "0"), kind: chunk4ZDR72SG_js.FrameTouchKind.pipeline, priority: chunk4ZDR72SG_js.ChunkPriority.now }));
+  }
+};
+function recordingAssets(assets, clock) {
+  return {
+    take(asset, priority = chunk4ZDR72SG_js.ChunkPriority.now, stall) {
+      let pending = assets.take(asset, priority, stall);
+      return clock.touch(asset, chunk4ZDR72SG_js.FrameTouchKind.take, priority, pending), pending;
+    },
+    progressive(asset, listener, priority = chunk4ZDR72SG_js.ChunkPriority.now, refine) {
+      let usable = () => {
+      }, first = new Promise((resolve) => {
+        usable = resolve;
+      }), observed = (...output) => {
+        usable(), listener?.(...output);
+      }, load = assets.progressive(asset, observed, priority, refine);
+      return load.done.then(usable, usable), clock.touch(asset, chunk4ZDR72SG_js.FrameTouchKind.progressive, priority, first), load;
+    },
+    prefetch(asset, priority = chunk4ZDR72SG_js.ChunkPriority.prefetch) {
+      return clock.touch(asset, chunk4ZDR72SG_js.FrameTouchKind.prefetch, priority, null), assets.prefetch(asset, priority);
+    },
+    isProgressive: (asset) => assets.isProgressive(asset),
+    has: (asset) => assets.has(asset),
+    lazy: (asset) => assets.lazy(asset),
+    requests: () => assets.requests(),
+    release: (asset) => assets.release(asset),
+    cancelPrefetch: (asset) => assets.cancelPrefetch(asset),
+    resident: (asset) => assets.resident(asset),
+    pending: (asset) => assets.pending(asset),
+    networkHint: () => assets.networkHint(),
+    onNetwork: (listener) => assets.onNetwork(listener),
+    module: (parts) => assets.module(parts),
+    joined: (sha256, parts) => assets.joined(sha256, parts)
+  };
+}
+var HeadlessSurface = class {
+  constructor(clock, mark) {
+    this.clock = clock;
+    this.mark = mark;
+    this.width = RECORD_SURFACE.width;
+    this.height = RECORD_SURFACE.height;
+    this.pixel_ratio = RECORD_SURFACE.pixel_ratio;
+    this.listener = null;
+  }
+  on_frame(listener) {
+    return this.mark("first_frame_scheduled"), this.listener !== null && this.clock.surfaces.delete(this.listener), this.listener = listener, this.clock.surfaces.add(listener), () => this.release();
+  }
+  on_resize() {
+    return NO_UNSUBSCRIBE;
+  }
+  on_pointer() {
+    return NO_UNSUBSCRIBE;
+  }
+  release() {
+    this.listener !== null && this.clock.surfaces.delete(this.listener), this.listener = null;
+  }
+};
+function silentAudio() {
+  let unavailable = (member) => () => {
+    throw new chunk6WUBSMTX_js.GuestUnavailableError(member);
+  };
+  return {
+    unlocked: false,
+    unlock: () => Promise.resolve(false),
+    bus: unavailable("audio.bus"),
+    load: () => Promise.reject(new chunk6WUBSMTX_js.GuestUnavailableError("audio.load")),
+    play: unavailable("audio.play"),
+    stop: unavailable("audio.stop")
+  };
+}
+var AUDIO_BOUND = 1, AUDIO_REGISTER_BYTES = 64, AUDIO_REGISTER_ALIGN = 16, SILENT_FRAMES = 1, SILENT_CHANNELS = 1, SILENT_RATE = 48e3, AUDIO_OK = 0;
+function silentAudioExports(alloc) {
+  let next = (1), registers = 0, id = () => ++next, ok = () => (0);
+  return {
+    engine_audio_bound: () => (1),
+    engine_audio_load_pcm: id,
+    engine_audio_load_wav: id,
+    engine_audio_release: ok,
+    engine_audio_create_bus: id,
+    engine_audio_set_bus_gain: ok,
+    engine_audio_set_bus_filter: ok,
+    engine_audio_set_duck: ok,
+    engine_audio_play: id,
+    engine_audio_replace: ok,
+    engine_audio_stop: ok,
+    engine_audio_set_voice_gain: ok,
+    engine_audio_set_voice_rate: ok,
+    engine_audio_is_playing: ok,
+    engine_audio_set_listener: ok,
+    engine_audio_place: ok,
+    engine_audio_set_voice_spatial: ok,
+    engine_audio_registers: () => (registers === 0 && (registers = alloc((64), (16))), registers),
+    engine_audio_update: ok,
+    engine_audio_meter: ok,
+    engine_audio_suspend: ok,
+    engine_audio_resume: ok,
+    engine_audio_reset: ok
+  };
+}
+function boundAudio(platform) {
+  if (platform.kind !== "engine") return platform;
+  let alloc = platform.runtime.exports.engine_alloc, silent = silentAudioExports(alloc), shaped = {};
+  for (let [name, impl] of Object.entries(silent)) {
+    let fn = (...args) => impl(...args);
+    Object.defineProperty(fn, "length", { value: chunk2O2CG465_js.ENGINE_EXPORT_ARITY[name] ?? 0 }), shaped[name] = fn;
+  }
+  let exports = { ...platform.runtime.exports, ...shaped }, decode_audio = (_bytes, done) => done(new Float32Array((1) * (1)), (1), (48e3));
+  return { kind: "engine", runtime: { ...platform.runtime, exports, decode_audio } };
+}
+function recordProfile(clock, assets, core, mark, heapPages = () => chunkO2ICABUD_js.engineHeapPages(void 0)) {
+  let platform = null;
+  return {
+    graphics: {
+      get features() {
+        throw new chunk6WUBSMTX_js.GuestUnavailableError("graphics.features");
+      },
+      engine() {
+        return platform ?? (platform = core.then((module) => chunkNZTKLY2W_js.wasmPlatformEngine(module, { memoryPages: heapPages() })).then((engine) => {
+          let peak = engine.kind === "engine" ? engine.runtime.exports.engine_heap_peak : void 0;
+          return typeof peak == "function" && (clock.heap = peak), boundAudio(engine);
+        })), platform;
+      },
+      acquire_surface: () => Promise.reject(new chunk6WUBSMTX_js.GuestUnavailableError("graphics.acquire_surface")),
+      attach_engine: async (render) => {
+        mark("attach_requested");
+        let attached = await platform;
+        return attached !== null && attached.kind === "engine" && clock.pipelines.attach(attached.runtime, render), mark("attach_resolved"), new HeadlessSurface(clock, mark);
+      },
+      on_context_lost: () => NO_UNSUBSCRIBE,
+      on_context_restored: () => NO_UNSUBSCRIBE
+    },
+    audio: silentAudio(),
+    assets: recordingAssets(assets, clock),
+    dialers: () => ({ primary: null, fallback: null })
+  };
+}
+function startRecordGuest(scope) {
+  let post = scope.postMessage.bind(scope), listen = scope.addEventListener.bind(scope), defer = (work) => {
+    scope.setTimeout(work, 0);
+  }, subtle = crypto.subtle, fillRandom = crypto.getRandomValues.bind(crypto), now = Date.now, importer = (url) => import(
+    /* @vite-ignore */
+    url
+  ), slice = new chunk6WUBSMTX_js.Slice(chunk6WUBSMTX_js.clockBudget(now)), send = (bytes, length) => {
+    let copy = bytes.slice(0, length);
+    post(copy.buffer, [copy.buffer]);
+  }, clock = new SteppedClock(send, defer), sendLogged = (bytes, length) => {
+    bytes[0] === chunk4ZDR72SG_js.MessageTag.chunk_request && chunk4ZDR72SG_js.forEachChunkEntry(
+      bytes.subarray(0, length),
+      chunk4ZDR72SG_js.CHUNK_REQUEST_ENTRY_BYTES,
+      (digest, priority) => clock.touch(chunk4ZDR72SG_js.CHUNK_TOUCH_PREFIX + digest, chunk4ZDR72SG_js.FrameTouchKind.chunk, priority, null)
+    ), send(bytes, length);
+  };
+  scope.requestAnimationFrame = clock.requestAnimationFrame.bind(clock), scope.cancelAnimationFrame = clock.cancelAnimationFrame.bind(clock);
+  let resolveCore = () => {
+  }, rejectCore = () => {
+  }, core = new Promise((resolve, reject) => {
+    resolveCore = resolve, rejectCore = reject;
+  }), bridge = {
+    send: sendLogged,
+    on_message(listener) {
+      listen("message", (event) => {
+        let bytes = new Uint8Array(event.data);
+        if (bytes[0] === chunk4ZDR72SG_js.MessageTag.frame_step) {
+          clock.step();
+          return;
+        }
+        listener(bytes), bytes[0] === chunk4ZDR72SG_js.MessageTag.start && defer(() => clock.step());
+      });
+    }
+  }, services = {
+    linker: chunkZMIL4ZOA_js.commonJsLinker(chunkZMIL4ZOA_js.blobCompiler(chunkZMIL4ZOA_js.BLOB_URLS, importer)),
+    slice,
+    harden: () => chunk6WUBSMTX_js.hardenGlobals(scope, () => slice.begin(), true),
+    now_ms: () => clock.frames * chunkAYJPHKYV_js.FIXED_STEP_MS,
+    random_fill: (out) => {
+      fillRandom(out);
+    },
+    async verify_ed25519(public_key, message, signature) {
+      let key = await subtle.importKey("raw", new Uint8Array(public_key), { name: ED25519 }, false, ["verify"]);
+      return subtle.verify({ name: ED25519 }, key, new Uint8Array(signature), new Uint8Array(message));
+    }
+  }, assets = new chunkAYJPHKYV_js.PackageAssets(), marks = { mark: () => {
+  } }, heapPages = chunkO2ICABUD_js.engineHeapPages(void 0), profile = recordProfile(clock, assets, core, (name) => marks.mark(name), () => heapPages), runtime = new chunk6WUBSMTX_js.GuestRuntime({
+    bridge,
+    services,
+    assets,
+    on_boot: (boot) => {
+      heapPages = chunkO2ICABUD_js.engineHeapPages(boot.engine_heap_bytes);
+    },
+    ctx: (guest) => chunk6WUBSMTX_js.createGuestCtx(guest, profile),
+    on_runtime_wasm: (unit, bytes) => {
+      unit === chunk4ZDR72SG_js.ENGINE_CORE_UNIT && chunk6SWKWCMS_js.compileApproved(bytes.slice()).then(resolveCore, rejectCore);
+    }
+  });
+  return marks.mark = (name) => runtime.mark(name), runtime;
+}
+startRecordGuest(globalThis);
+
+exports.PipelineLog = PipelineLog;
+exports.RECORD_SURFACE = RECORD_SURFACE;
+exports.SteppedClock = SteppedClock;
+exports.recordProfile = recordProfile;
+exports.recordingAssets = recordingAssets;
+exports.startRecordGuest = startRecordGuest;