@cimplify/sdk 0.108.0 → 0.110.2

package/dist/interactives-record.mjs

@@ -0,0 +1,295 @@
+import { PackageAssets, FIXED_STEP_MS } from './chunk-UG5BTOTF.mjs';
+import { engineHeapPages } from './chunk-JURRXY2J.mjs';
+import { wasmPlatformEngine } from './chunk-GHS6MIL6.mjs';
+import './chunk-GDCV4IWO.mjs';
+import './chunk-Y66WVMO5.mjs';
+import './chunk-U6UVWEAK.mjs';
+import { ENGINE_EXPORT_ARITY } from './chunk-A33OORT7.mjs';
+import { Slice, clockBudget, GuestRuntime, createGuestCtx, hardenGlobals, GuestUnavailableError } from './chunk-3VEH23I5.mjs';
+import './chunk-5C3C7VDM.mjs';
+import './chunk-UGH37BQW.mjs';
+import { commonJsLinker, blobCompiler, BLOB_URLS } from './chunk-KDQOR4QQ.mjs';
+import './chunk-LYEZZEEF.mjs';
+import './chunk-HAGEIC2L.mjs';
+import './chunk-K46SMZ66.mjs';
+import './chunk-OKC2B4O3.mjs';
+import './chunk-PPF2BYFL.mjs';
+import './chunk-WLMINRC4.mjs';
+import './chunk-RFVRPYR2.mjs';
+import './chunk-DS2VU4WW.mjs';
+import './chunk-5YWN6H5Q.mjs';
+import './chunk-F6XRYEM3.mjs';
+import './chunk-OQRVEM56.mjs';
+import './chunk-SPCRQ6NO.mjs';
+import { ENGINE_CORE_UNIT, encodeFrameMark, MessageTag, forEachChunkEntry, CHUNK_REQUEST_ENTRY_BYTES, CHUNK_TOUCH_PREFIX, FrameTouchKind, ChunkPriority, PIPELINE_TOUCH_PREFIX } from './chunk-V7ZRH3PY.mjs';
+import './chunk-GYLP6UG4.mjs';
+import './chunk-XJA2NGTI.mjs';
+import './chunk-2IC4H6OV.mjs';
+import './chunk-MOMOZEUM.mjs';
+import { compileApproved } from './chunk-N4RGGDEL.mjs';
+import './chunk-XJIHN3BY.mjs';
+import './chunk-25T4JHEA.mjs';
+
+// 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 * 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 = 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: PIPELINE_TOUCH_PREFIX + key.toString((16)).padStart((16), "0"), kind: FrameTouchKind.pipeline, priority: ChunkPriority.now }));
+  }
+};
+function recordingAssets(assets, clock) {
+  return {
+    take(asset, priority = ChunkPriority.now, stall) {
+      let pending = assets.take(asset, priority, stall);
+      return clock.touch(asset, FrameTouchKind.take, priority, pending), pending;
+    },
+    progressive(asset, listener, priority = 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, FrameTouchKind.progressive, priority, first), load;
+    },
+    prefetch(asset, priority = ChunkPriority.prefetch) {
+      return clock.touch(asset, 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 GuestUnavailableError(member);
+  };
+  return {
+    unlocked: false,
+    unlock: () => Promise.resolve(false),
+    bus: unavailable("audio.bus"),
+    load: () => Promise.reject(new 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: 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 = () => engineHeapPages(void 0)) {
+  let platform = null;
+  return {
+    graphics: {
+      get features() {
+        throw new GuestUnavailableError("graphics.features");
+      },
+      engine() {
+        return platform ?? (platform = core.then((module) => 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 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 Slice(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] === MessageTag.chunk_request && forEachChunkEntry(
+      bytes.subarray(0, length),
+      CHUNK_REQUEST_ENTRY_BYTES,
+      (digest, priority) => clock.touch(CHUNK_TOUCH_PREFIX + digest, 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] === MessageTag.frame_step) {
+          clock.step();
+          return;
+        }
+        listener(bytes), bytes[0] === MessageTag.start && defer(() => clock.step());
+      });
+    }
+  }, services = {
+    linker: commonJsLinker(blobCompiler(BLOB_URLS, importer)),
+    slice,
+    harden: () => hardenGlobals(scope, () => slice.begin(), true),
+    now_ms: () => clock.frames * 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 PackageAssets(), marks = { mark: () => {
+  } }, heapPages = engineHeapPages(void 0), profile = recordProfile(clock, assets, core, (name) => marks.mark(name), () => heapPages), runtime = new GuestRuntime({
+    bridge,
+    services,
+    assets,
+    on_boot: (boot) => {
+      heapPages = engineHeapPages(boot.engine_heap_bytes);
+    },
+    ctx: (guest) => createGuestCtx(guest, profile),
+    on_runtime_wasm: (unit, bytes) => {
+      unit === ENGINE_CORE_UNIT && compileApproved(bytes.slice()).then(resolveCore, rejectCore);
+    }
+  });
+  return marks.mark = (name) => runtime.mark(name), runtime;
+}
+startRecordGuest(globalThis);
+
+export { PipelineLog, RECORD_SURFACE, SteppedClock, recordProfile, recordingAssets, startRecordGuest };

package/dist/interactives-runtime.d.mts

@@ -0,0 +1,61 @@
+export { e as AssembledPackage, B as BLOB_URLS, f as BRIDGE_LIMITS, g as BRIDGE_PROTOCOL_VERSION, h as CHUNK_COUNT_BYTES, i as CHUNK_FAILED_BYTES, j as CHUNK_FAILURE_BY_CODE, k as CHUNK_RELEASE_ENTRY_BYTES, l as CHUNK_REQUESTS_VERSION, m as CHUNK_REQUEST_ENTRY_BYTES, n as CHUNK_TOUCH_PREFIX, o as CTX_CONFIRMED_REQUEST_DEADLINE_MS, p as CTX_LONG_REQUEST_DEADLINES_MS, q as CTX_REQUEST_DEADLINE_MS, r as ChannelPublisher, s as ChunkBatch, t as ChunkFailure, a as ChunkFailureName, u as ChunkKind, b as ChunkPriority, v as CommonJsModule, D as DEFAULT_SLICE_MS, w as DIGEST_BYTES, E as ENGINE_CORE_THREADS_UNIT, x as ENGINE_CORE_UNIT, y as EngineServices, z as FaultPhase, H as FrameLane, J as FrameMark, F as FrameTouch, c as FrameTouchKind, K as GuestBoot, L as GuestCore, N as GuestEntry, O as GuestFault, P as GuestOptions, G as GuestRuntime, Q as GuestUiReply, R as GuestUnavailableError, S as HostBridge, T as HotRequest, U as HotSwapReport, V as HotSwapResult, W as INSPECTOR_BYTES, X as INSPECTOR_HIDDEN, Y as INSPECTOR_SHOWN, Z as IndexedImport, _ as IndexedModule, $ as LIFECYCLE_BYTES, a0 as LIFECYCLE_BY_CODE, a1 as LaneCounter, a2 as LaneFastReader, a3 as LifecycleCode, a4 as LifecycleName, a5 as LinkableModule, a6 as MAX_CHUNK_BATCH, a7 as MILESTONE_BYTES, a8 as MILESTONE_BY_CODE, a9 as MODULE_INDEX_FORMAT, aa as MODULE_PARAMETERS, ab as MessageListener, ac as MessageTag, ad as MessageWriter, ae as Milestone, M as MilestoneName, af as ModuleCompiler, ag as ModuleFactory, ah as ModuleImport, ai as ModuleImporter, aj as ModuleIndex, ak as ModuleLinker, al as ModuleRequire, am as PING_BYTES, an as PIPELINE_TOUCH_PREFIX, ao as PONG_BYTES, ap as PREFETCH_BUDGET_SHARE, aq as PREFETCH_SLOT_SHARE, ar as PackageAssembler, as as PackageError, at as RUNTIME_PATH_PREFIX, au as RUNTIME_WASM_SUFFIX, av as RoomInputPublisher, aw as RuntimeUnitSource, ax as SESSION_COMPLETE_BYTES, ay as SESSION_OUTCOME_BY_CODE, az as SESSION_PROTOCOL_VERSION, aA as SessionCompleteMessage, aB as SessionOutcomeCode, aC as SessionOutcomeName, aD as Slice, aE as SliceBudget, aF as SliceExceeded, aG as TAG_BYTES, aH as TICKS_PER_CHECK, aI as TICK_GLOBAL, aJ as Tick, aK as UiCommand, aL as UrlFactory, aM as VERBOSE_MODULE_INDEX_FORMAT, aN as blobCompiler, aO as chunkEntryCount, aP as chunkEntryOffset, aQ as clockBudget, aR as commonJsLinker, aS as createGuestCtx, aT as ctxFamilyOf, aU as ctxRequestDeadlineMs, aV as decodeChunk, aW as encodeFrameMark, aX as forEachChunkEntry, aY as hex, aZ as hexAt, a_ as linkOrder, a$ as moduleWrapper, b0 as prefetchSlots, b1 as readChunkFailed, b2 as readFrameMark, b3 as readIndex, b4 as readJson, b5 as readSessionComplete, b6 as readText, b7 as tagOf, b8 as unhex, b9 as unhexAt, ba as utf8, bb as writeChunkFailed, bc as writeSessionComplete } from './guest-DrsA00XD.mjs';
+export { T as TreeDiffer, a as TreeError, b as TreeMirror, c as TreePatch, d as TreePath } from './tree-C-Io2Hbx.mjs';
+import { F as FaceColours } from './local-D8_I6UeL.mjs';
+import './link-BUTqGmyi.mjs';
+import './network-ZXLD7l1b.mjs';
+import './schema-BrWxzKp6.mjs';
+import './ui-DwHicuFv.mjs';
+import './vars-Dc_PrhBK.mjs';
+
+declare class GuardError extends Error {
+    constructor(member: string);
+}
+declare function hardenGlobals(global: Record<string, unknown>, onTask: () => void, runtimeWasm?: boolean): void;
+
+declare const SHA256_BYTES = 32;
+declare function sha256Into(input: Uint8Array, out: Uint8Array): void;
+
+type FaceColour = readonly [number, number, number];
+interface SampledColours {
+    readonly skin: FaceColour;
+    readonly hair: FaceColour | null;
+    readonly eye: FaceColour | null;
+}
+declare function packColour(colour: FaceColour | null): number;
+declare function packColours(colours: SampledColours): FaceColours;
+interface PixelSource {
+    readonly width: number;
+    readonly height: number;
+    read(x: number, y: number, width: number, height: number): Uint8ClampedArray | Uint8Array;
+}
+declare class FaceColourSampler {
+    private readonly bins;
+    private count;
+    sample(source: PixelSource, landmarks: Float32Array): SampledColours;
+    private reset;
+    private patch;
+    private median;
+}
+declare function landmarksPresent(landmarks: Float32Array): boolean;
+interface VideoPixels {
+    readonly videoWidth: number;
+    readonly videoHeight: number;
+}
+declare class VideoPixelSource implements PixelSource {
+    private readonly video;
+    private context;
+    private canvas;
+    width: number;
+    height: number;
+    constructor(video: VideoPixels & CanvasImageSource);
+    capture(): boolean;
+    read(x: number, y: number, width: number, height: number): Uint8ClampedArray;
+}
+declare class WebFaceColours {
+    private readonly source;
+    private readonly sampler;
+    constructor(video: VideoPixels & CanvasImageSource);
+    sample(landmarks: Float32Array): FaceColours | null;
+}
+
+export { FaceColourSampler, GuardError, type PixelSource, SHA256_BYTES, type SampledColours, VideoPixelSource, WebFaceColours, hardenGlobals, landmarksPresent, packColour, packColours, sha256Into };

package/dist/interactives-runtime.d.ts

@@ -0,0 +1,61 @@
+export { e as AssembledPackage, B as BLOB_URLS, f as BRIDGE_LIMITS, g as BRIDGE_PROTOCOL_VERSION, h as CHUNK_COUNT_BYTES, i as CHUNK_FAILED_BYTES, j as CHUNK_FAILURE_BY_CODE, k as CHUNK_RELEASE_ENTRY_BYTES, l as CHUNK_REQUESTS_VERSION, m as CHUNK_REQUEST_ENTRY_BYTES, n as CHUNK_TOUCH_PREFIX, o as CTX_CONFIRMED_REQUEST_DEADLINE_MS, p as CTX_LONG_REQUEST_DEADLINES_MS, q as CTX_REQUEST_DEADLINE_MS, r as ChannelPublisher, s as ChunkBatch, t as ChunkFailure, a as ChunkFailureName, u as ChunkKind, b as ChunkPriority, v as CommonJsModule, D as DEFAULT_SLICE_MS, w as DIGEST_BYTES, E as ENGINE_CORE_THREADS_UNIT, x as ENGINE_CORE_UNIT, y as EngineServices, z as FaultPhase, H as FrameLane, J as FrameMark, F as FrameTouch, c as FrameTouchKind, K as GuestBoot, L as GuestCore, N as GuestEntry, O as GuestFault, P as GuestOptions, G as GuestRuntime, Q as GuestUiReply, R as GuestUnavailableError, S as HostBridge, T as HotRequest, U as HotSwapReport, V as HotSwapResult, W as INSPECTOR_BYTES, X as INSPECTOR_HIDDEN, Y as INSPECTOR_SHOWN, Z as IndexedImport, _ as IndexedModule, $ as LIFECYCLE_BYTES, a0 as LIFECYCLE_BY_CODE, a1 as LaneCounter, a2 as LaneFastReader, a3 as LifecycleCode, a4 as LifecycleName, a5 as LinkableModule, a6 as MAX_CHUNK_BATCH, a7 as MILESTONE_BYTES, a8 as MILESTONE_BY_CODE, a9 as MODULE_INDEX_FORMAT, aa as MODULE_PARAMETERS, ab as MessageListener, ac as MessageTag, ad as MessageWriter, ae as Milestone, M as MilestoneName, af as ModuleCompiler, ag as ModuleFactory, ah as ModuleImport, ai as ModuleImporter, aj as ModuleIndex, ak as ModuleLinker, al as ModuleRequire, am as PING_BYTES, an as PIPELINE_TOUCH_PREFIX, ao as PONG_BYTES, ap as PREFETCH_BUDGET_SHARE, aq as PREFETCH_SLOT_SHARE, ar as PackageAssembler, as as PackageError, at as RUNTIME_PATH_PREFIX, au as RUNTIME_WASM_SUFFIX, av as RoomInputPublisher, aw as RuntimeUnitSource, ax as SESSION_COMPLETE_BYTES, ay as SESSION_OUTCOME_BY_CODE, az as SESSION_PROTOCOL_VERSION, aA as SessionCompleteMessage, aB as SessionOutcomeCode, aC as SessionOutcomeName, aD as Slice, aE as SliceBudget, aF as SliceExceeded, aG as TAG_BYTES, aH as TICKS_PER_CHECK, aI as TICK_GLOBAL, aJ as Tick, aK as UiCommand, aL as UrlFactory, aM as VERBOSE_MODULE_INDEX_FORMAT, aN as blobCompiler, aO as chunkEntryCount, aP as chunkEntryOffset, aQ as clockBudget, aR as commonJsLinker, aS as createGuestCtx, aT as ctxFamilyOf, aU as ctxRequestDeadlineMs, aV as decodeChunk, aW as encodeFrameMark, aX as forEachChunkEntry, aY as hex, aZ as hexAt, a_ as linkOrder, a$ as moduleWrapper, b0 as prefetchSlots, b1 as readChunkFailed, b2 as readFrameMark, b3 as readIndex, b4 as readJson, b5 as readSessionComplete, b6 as readText, b7 as tagOf, b8 as unhex, b9 as unhexAt, ba as utf8, bb as writeChunkFailed, bc as writeSessionComplete } from './guest-wIdfoT05.js';
+export { T as TreeDiffer, a as TreeError, b as TreeMirror, c as TreePatch, d as TreePath } from './tree-CP_qSW4H.js';
+import { F as FaceColours } from './local-VZkqsCzR.js';
+import './link-BUTqGmyi.js';
+import './network-ZXLD7l1b.js';
+import './schema-BrWxzKp6.js';
+import './ui-hi7S2YcH.js';
+import './vars-Dc_PrhBK.js';
+
+declare class GuardError extends Error {
+    constructor(member: string);
+}
+declare function hardenGlobals(global: Record<string, unknown>, onTask: () => void, runtimeWasm?: boolean): void;
+
+declare const SHA256_BYTES = 32;
+declare function sha256Into(input: Uint8Array, out: Uint8Array): void;
+
+type FaceColour = readonly [number, number, number];
+interface SampledColours {
+    readonly skin: FaceColour;
+    readonly hair: FaceColour | null;
+    readonly eye: FaceColour | null;
+}
+declare function packColour(colour: FaceColour | null): number;
+declare function packColours(colours: SampledColours): FaceColours;
+interface PixelSource {
+    readonly width: number;
+    readonly height: number;
+    read(x: number, y: number, width: number, height: number): Uint8ClampedArray | Uint8Array;
+}
+declare class FaceColourSampler {
+    private readonly bins;
+    private count;
+    sample(source: PixelSource, landmarks: Float32Array): SampledColours;
+    private reset;
+    private patch;
+    private median;
+}
+declare function landmarksPresent(landmarks: Float32Array): boolean;
+interface VideoPixels {
+    readonly videoWidth: number;
+    readonly videoHeight: number;
+}
+declare class VideoPixelSource implements PixelSource {
+    private readonly video;
+    private context;
+    private canvas;
+    width: number;
+    height: number;
+    constructor(video: VideoPixels & CanvasImageSource);
+    capture(): boolean;
+    read(x: number, y: number, width: number, height: number): Uint8ClampedArray;
+}
+declare class WebFaceColours {
+    private readonly source;
+    private readonly sampler;
+    constructor(video: VideoPixels & CanvasImageSource);
+    sample(landmarks: Float32Array): FaceColours | null;
+}
+
+export { FaceColourSampler, GuardError, type PixelSource, SHA256_BYTES, type SampledColours, VideoPixelSource, WebFaceColours, hardenGlobals, landmarksPresent, packColour, packColours, sha256Into };