@cimplify/sdk 0.108.0 → 0.110.2

package/dist/audio-m0w8cnxq.d.ts

@@ -0,0 +1,249 @@
+import { A as AudioPort, M as MusicQuantize, O as OcclusionDesc, b as AssetSource, c as AudioCapabilities, S as SoundLimitDesc, P as PannerDesc, d as FilterDesc, L as LimiterDesc, e as AnalyserDesc, F as FrameTime } from './backend-gUCzs5Kg.js';
+import { T as Transforms, E as Entity, a as EntityTable, b as TableSchema } from './world-PvILHDR1.js';
+
+interface Tempo {
+    readonly bpm: number;
+    readonly beatsPerBar?: number;
+}
+interface MusicStem {
+    readonly sound: SoundId;
+    readonly gain?: number;
+}
+interface SegmentOptions {
+    readonly bars?: number;
+    readonly bus?: BusId;
+    readonly quantize?: MusicQuantize;
+    readonly fadeSeconds?: number;
+}
+interface StingerOptions {
+    readonly bus?: BusId;
+    readonly gain?: number;
+    readonly quantize?: MusicQuantize;
+}
+interface MusicPosition {
+    readonly bar: number;
+    readonly beat: number;
+    readonly fraction: number;
+}
+/**
+ * Interactive music on the engine's beat clock: segments of layered stems that loop on the bar grid, transitions and
+ * stingers that land on the next beat, bar or phrase, and per-layer gains for intensity. Every start is sample
+ * accurate in the mix and lockstep deterministic. Returned frames are output frames at 48 kHz.
+ */
+declare class Music {
+    private readonly port;
+    private readonly defaultBus;
+    private readonly sounds;
+    private readonly gains;
+    private readonly where;
+    constructor(port: AudioPort, defaultBus: BusId);
+    get available(): boolean;
+    private require;
+    private checked;
+    /** Starts the beat grid, or changes tempo on the next `quantize` boundary. Returns the grid's first frame. */
+    setTempo(tempo: Tempo, quantize?: MusicQuantize): number;
+    /** Plays the stems as one segment looping every `bars` bars from the next boundary; the playing segment stops there. */
+    play(stems: readonly MusicStem[], options?: SegmentOptions): number;
+    /** Sets one layer's gain, for the repeats playing and the ones to come. */
+    setLayer(layer: number, gain: number, rampSeconds?: number): void;
+    /** Plays a one-shot on the next boundary. */
+    stinger(sound: SoundId, options?: StingerOptions): VoiceId;
+    /** Stops the segment on the next boundary. Returns the stop frame. */
+    stop(quantize?: MusicQuantize, fadeSeconds?: number): number;
+    /** Where the mix is on the grid, or null before a tempo is set. */
+    position(): MusicPosition | null;
+}
+
+interface ImpulseDesc {
+    readonly seconds?: number;
+    readonly decay?: number;
+    readonly preDelay?: number;
+    readonly damping?: number;
+    readonly width?: number;
+    readonly seed?: number;
+    readonly channels?: 1 | 2;
+}
+interface ImpulseResponse {
+    readonly samples: Float32Array;
+    readonly channels: number;
+    readonly sampleRate: number;
+    readonly frames: number;
+}
+declare const REVERB_PRESETS: {
+    readonly room: {
+        readonly seconds: 0.8;
+        readonly decay: 3;
+        readonly preDelay: 0.005;
+        readonly damping: 0.5;
+        readonly width: 1;
+    };
+    readonly hall: {
+        readonly seconds: 2.4;
+        readonly decay: 2.2;
+        readonly preDelay: 0.02;
+        readonly damping: 0.35;
+        readonly width: 1;
+    };
+    readonly cathedral: {
+        readonly seconds: 5;
+        readonly decay: 1.6;
+        readonly preDelay: 0.04;
+        readonly damping: 0.25;
+        readonly width: 1;
+    };
+    readonly plate: {
+        readonly seconds: 1.6;
+        readonly decay: 2.8;
+        readonly preDelay: 0;
+        readonly damping: 0.1;
+        readonly width: 0.8;
+    };
+    readonly cave: {
+        readonly seconds: 3.5;
+        readonly decay: 1.8;
+        readonly preDelay: 0.03;
+        readonly damping: 0.6;
+        readonly width: 1;
+    };
+    readonly tunnel: {
+        readonly seconds: 2.8;
+        readonly decay: 2;
+        readonly preDelay: 0.06;
+        readonly damping: 0.45;
+        readonly width: 0.6;
+    };
+};
+type ReverbPreset = keyof typeof REVERB_PRESETS;
+declare function impulseFrames(desc: ImpulseDesc, sampleRate: number): number;
+declare function writeImpulse(desc: ImpulseDesc, sampleRate: number, out: Float32Array): number;
+declare function generateImpulse(desc: ImpulseDesc | ReverbPreset, sampleRate: number, seed?: number): ImpulseResponse;
+
+declare const soundBrand: unique symbol;
+declare const busBrand: unique symbol;
+declare const voiceBrand: unique symbol;
+declare const analyserBrand: unique symbol;
+declare const streamBrand: unique symbol;
+declare const emitterBrand: unique symbol;
+type EmitterFeedId = number & {
+    readonly [emitterBrand]: true;
+};
+interface EmitterFields {
+    readonly position: string | readonly [string, string, string];
+    readonly velocity?: string | readonly [string, string, string];
+    readonly gain?: string;
+    readonly pitch?: string;
+}
+interface EmitterOptions {
+    readonly sound: SoundId;
+    readonly capacity?: number;
+    readonly panner?: PannerDesc;
+}
+type SoundId = number & {
+    readonly [soundBrand]: true;
+};
+type BusId = number & {
+    readonly [busBrand]: true;
+};
+type VoiceId = number & {
+    readonly [voiceBrand]: true;
+};
+type AnalyserId = number & {
+    readonly [analyserBrand]: true;
+};
+type StreamId = number & {
+    readonly [streamBrand]: true;
+};
+interface ReverbDesc {
+    readonly impulse?: SoundId | ImpulseDesc | ReverbPreset;
+    readonly parent?: BusId;
+    readonly seed?: number;
+}
+declare function encodePanner(desc: PannerDesc, out: Float32Array): Float32Array;
+declare function validateLoop(startSeconds: number, endSeconds: number): void;
+declare class Audio {
+    readonly master: BusId;
+    readonly music: BusId;
+    readonly effects: BusId;
+    readonly conductor: Music;
+    private readonly port;
+    private readonly occlusion;
+    private readonly transforms;
+    private readonly voiceIds;
+    private readonly voiceEntity;
+    private listenerEntity;
+    private duckBus;
+    private duckRemaining;
+    private duckRelease;
+    private readonly busGain;
+    private readonly spatial;
+    private readonly loopStarts;
+    private readonly loopEnds;
+    private readonly feeds;
+    private readonly pose;
+    private readonly stepFrame;
+    private stepped;
+    private lockstepped;
+    constructor(port: AudioPort, transforms: Transforms, maxVoices?: number);
+    /** The first output frame (48 kHz) a scheduled start or stop sent now can land on exactly. */
+    get frame(): number;
+    /** Plays `sound` starting on output frame `frame`, sample accurate in the mix; a past frame starts at once. */
+    playOn(frame: number, sound: SoundId, bus: BusId, gain?: number, rate?: number, loop?: boolean, priority?: number): VoiceId;
+    /** Stops `voice` on output frame `frame`, fading over `fadeSeconds` from there. */
+    stopOn(voice: VoiceId, frame: number, fadeSeconds?: number): void;
+    /** Renders a positional voice through head-related transfer functions, for headphones, in place of panning. */
+    setBinaural(voice: VoiceId, on: boolean): void;
+    /** Lets physics geometry between the listener and a positional voice quiet and darken it; null turns it off. */
+    setOcclusion(voice: VoiceId, desc: OcclusionDesc | null): void;
+    get unlocked(): boolean;
+    unlock(): void;
+    load(source: AssetSource): Promise<SoundId>;
+    createBus(name: string, parent: BusId): BusId;
+    setBusGain(bus: BusId, gain: number, rampSeconds?: number): void;
+    duck(bus: BusId, gain: number, holdSeconds: number, rampSeconds: number): void;
+    get capabilities(): AudioCapabilities;
+    get sampleRate(): number;
+    createSound(samples: Float32Array, channels: number, sampleRate?: number): SoundId;
+    play(sound: SoundId, bus: BusId, gain?: number, rate?: number, loop?: boolean, priority?: number): VoiceId;
+    setSoundLimit(sound: SoundId, limit: SoundLimitDesc | null): void;
+    setVoiceBudget(voices: number | null): void;
+    setVolume(voice: VoiceId, gain: number, rampSeconds?: number): void;
+    setPlaybackRate(voice: VoiceId, rate: number, detuneCents?: number): void;
+    setPanner(voice: VoiceId, desc: PannerDesc): void;
+    setFilter(bus: BusId, desc: FilterDesc | null): void;
+    setVoiceFilter(voice: VoiceId, desc: FilterDesc | null): void;
+    setLimiter(desc: LimiterDesc | null): void;
+    meter(bus: BusId, out: Float32Array): void;
+    createAnalyser(bus: BusId, desc?: AnalyserDesc): AnalyserId;
+    frequencyData(analyser: AnalyserId, out: Float32Array | Uint8Array): void;
+    timeDomainData(analyser: AnalyserId, out: Float32Array | Uint8Array): void;
+    createReverb(desc?: ReverbDesc): BusId;
+    setSend(bus: BusId, target: BusId, amount: number): void;
+    setLoopPoints(sound: SoundId, startSeconds: number, endSeconds: number): void;
+    setVoiceLoop(voice: VoiceId, loop: boolean, startSeconds?: number, endSeconds?: number): void;
+    openStream(source: AssetSource, bus?: BusId): Promise<StreamId>;
+    playStream(stream: StreamId, gain?: number, loop?: boolean): void;
+    pauseStream(stream: StreamId): void;
+    seekStream(stream: StreamId, seconds: number): void;
+    streamTime(stream: StreamId): number;
+    streamDuration(stream: StreamId): number;
+    closeStream(stream: StreamId): void;
+    private applySoundLoop;
+    private require;
+    playAt(entity: Entity, sound: SoundId, bus: BusId, gain?: number, rate?: number, loop?: boolean, panner?: PannerDesc, priority?: number): VoiceId;
+    stop(voice: VoiceId, fadeSeconds?: number): void;
+    isPlaying(voice: VoiceId): boolean;
+    setListener(entity: Entity): void;
+    feedEmitters(bus: BusId, table: EntityTable<TableSchema>, fields: EmitterFields, options: EmitterOptions): EmitterFeedId;
+    stopEmitters(feed: EmitterFeedId): void;
+    setLockstep(on: boolean): void;
+    get lockstep(): boolean;
+    fixedStep(time: FrameTime): void;
+    private stepLocked;
+    private feedAll;
+    suspend(): void;
+    resume(): void;
+    update(time: FrameTime): void;
+    private restingGain;
+}
+
+export { Audio as A, type BusId as B, type EmitterFeedId as E, type ImpulseDesc as I, Music as M, REVERB_PRESETS as R, type SoundId as S, type VoiceId as V, type AnalyserId as a, type EmitterFields as b, type EmitterOptions as c, type ImpulseResponse as d, type ReverbDesc as e, type ReverbPreset as f, type StreamId as g, encodePanner as h, generateImpulse as i, impulseFrames as j, validateLoop as v, writeImpulse as w };

package/dist/avatars.d.mts

@@ -0,0 +1,110 @@
+import { R as Rgb, g as AssistiveSide, a as IdentityParams } from './params-DxFb5G_U.mjs';
+
+type AvatarDrawStyle = "toon_3d" | "comic";
+type AvatarPose = "neutral" | "warm" | "cool" | "playful";
+type HairShape = "bald" | "crop" | "cap" | "curls" | "afro" | "long" | "buns";
+interface AvatarLookItem {
+    readonly slot: string;
+    readonly item_id: string;
+}
+interface AvatarSource {
+    readonly identity: string | Uint8Array;
+    readonly hash: string;
+    readonly art_style?: string;
+    readonly pose_style?: AvatarPose;
+    readonly items?: readonly AvatarLookItem[];
+    readonly portrait_url?: string | null;
+}
+interface AvatarRecordLike {
+    readonly identity: string;
+    readonly hash: string;
+    readonly art_style: string;
+    readonly active_look: number;
+    readonly portrait_url: string;
+    readonly looks: readonly {
+        readonly look: number;
+        readonly pose_style: AvatarPose;
+        readonly items: readonly AvatarLookItem[];
+    }[];
+}
+interface AvatarFace {
+    readonly skin: Rgb;
+    readonly hair: Rgb;
+    readonly hairTip: Rgb;
+    readonly eye: Rgb;
+    readonly outfit: Rgb;
+    readonly accent: Rgb;
+    readonly backdrop: Rgb;
+    readonly hairShape: HairShape;
+    readonly hairVolume: number;
+    readonly hairLength: number;
+    readonly coily: number;
+    readonly covered: boolean;
+    readonly brows: number;
+    readonly facialHair: number;
+    readonly width: number;
+    readonly length: number;
+    readonly pose: AvatarPose;
+    readonly glasses: boolean;
+    readonly hearing: AssistiveSide | null;
+    readonly patches: number;
+    readonly seed: number;
+}
+declare function base64Bytes(text: string): Uint8Array;
+declare function stableHash(text: string): number;
+declare function sourceOfRecord(record: AvatarRecordLike): AvatarSource;
+declare function avatarFaceOf(params: IdentityParams, source: Omit<AvatarSource, "identity">): AvatarFace;
+declare function avatarFace(source: AvatarSource): AvatarFace | null;
+
+interface AvatarDrawOptions {
+    readonly style: AvatarDrawStyle;
+    readonly size: number;
+    readonly backdrop?: boolean;
+}
+declare function avatarSvg(face: AvatarFace, options: AvatarDrawOptions): string;
+declare function avatarSvgUri(svg: string): string;
+
+type AvatarRenderKind = "portrait" | "bust" | "pin";
+type AvatarRenderStatus = "idle" | "loading" | "ready" | "pending" | "failed";
+interface AvatarRenderState {
+    readonly status: AvatarRenderStatus;
+    readonly src: string | null;
+}
+declare const RENDER_SIZES: readonly number[];
+declare const RENDER_PENDING_HEADER = "x-avatar-render";
+declare const RENDER_PENDING_VALUE = "pending";
+declare const RENDER_PENDING_RETRY_MS = 5000;
+declare const RENDER_PENDING_TRIES = 6;
+declare const MAX_KEPT_RENDERS = 256;
+interface RenderLoaderPorts {
+    readonly fetch: (url: string) => Promise<Response>;
+    readonly objectUrl: (blob: Blob) => string;
+    readonly revoke: (url: string) => void;
+    readonly later: (run: () => void, ms: number) => void;
+}
+declare class AvatarRenderCache {
+    private readonly states;
+    private readonly tries;
+    private readonly listeners;
+    private ports;
+    constructor(ports?: RenderLoaderPorts | null);
+    readonly subscribe: (listener: () => void) => (() => void);
+    state(url: string | null): AvatarRenderState;
+    request(url: string): void;
+    clear(): void;
+    private load;
+    private pending;
+    private set;
+    private notify;
+}
+declare const avatarRenders: AvatarRenderCache;
+declare function renderSize(size: number, pixelRatio?: number): number;
+declare function avatarRenderUrl(source: Pick<AvatarSource, "hash">, apiBase: string, options: {
+    readonly style: AvatarDrawStyle;
+    readonly size: number;
+    readonly kind?: AvatarRenderKind;
+    readonly pixelRatio?: number;
+}): string | null;
+declare function drawnAvatarUri(source: AvatarSource, options: AvatarDrawOptions): string | null;
+
+export { type AvatarDrawOptions, type AvatarDrawStyle, type AvatarFace, type AvatarLookItem, type AvatarPose, type AvatarRecordLike, AvatarRenderCache, type AvatarRenderKind, type AvatarRenderState, type AvatarRenderStatus, type AvatarSource, type HairShape, MAX_KEPT_RENDERS, RENDER_PENDING_HEADER, RENDER_PENDING_RETRY_MS, RENDER_PENDING_TRIES, RENDER_PENDING_VALUE, RENDER_SIZES, type RenderLoaderPorts, avatarFace, avatarFaceOf, avatarRenderUrl, avatarRenders, avatarSvg, avatarSvgUri, base64Bytes, drawnAvatarUri, renderSize, sourceOfRecord, stableHash };

package/dist/avatars.d.ts

@@ -0,0 +1,110 @@
+import { R as Rgb, g as AssistiveSide, a as IdentityParams } from './params-DxFb5G_U.js';
+
+type AvatarDrawStyle = "toon_3d" | "comic";
+type AvatarPose = "neutral" | "warm" | "cool" | "playful";
+type HairShape = "bald" | "crop" | "cap" | "curls" | "afro" | "long" | "buns";
+interface AvatarLookItem {
+    readonly slot: string;
+    readonly item_id: string;
+}
+interface AvatarSource {
+    readonly identity: string | Uint8Array;
+    readonly hash: string;
+    readonly art_style?: string;
+    readonly pose_style?: AvatarPose;
+    readonly items?: readonly AvatarLookItem[];
+    readonly portrait_url?: string | null;
+}
+interface AvatarRecordLike {
+    readonly identity: string;
+    readonly hash: string;
+    readonly art_style: string;
+    readonly active_look: number;
+    readonly portrait_url: string;
+    readonly looks: readonly {
+        readonly look: number;
+        readonly pose_style: AvatarPose;
+        readonly items: readonly AvatarLookItem[];
+    }[];
+}
+interface AvatarFace {
+    readonly skin: Rgb;
+    readonly hair: Rgb;
+    readonly hairTip: Rgb;
+    readonly eye: Rgb;
+    readonly outfit: Rgb;
+    readonly accent: Rgb;
+    readonly backdrop: Rgb;
+    readonly hairShape: HairShape;
+    readonly hairVolume: number;
+    readonly hairLength: number;
+    readonly coily: number;
+    readonly covered: boolean;
+    readonly brows: number;
+    readonly facialHair: number;
+    readonly width: number;
+    readonly length: number;
+    readonly pose: AvatarPose;
+    readonly glasses: boolean;
+    readonly hearing: AssistiveSide | null;
+    readonly patches: number;
+    readonly seed: number;
+}
+declare function base64Bytes(text: string): Uint8Array;
+declare function stableHash(text: string): number;
+declare function sourceOfRecord(record: AvatarRecordLike): AvatarSource;
+declare function avatarFaceOf(params: IdentityParams, source: Omit<AvatarSource, "identity">): AvatarFace;
+declare function avatarFace(source: AvatarSource): AvatarFace | null;
+
+interface AvatarDrawOptions {
+    readonly style: AvatarDrawStyle;
+    readonly size: number;
+    readonly backdrop?: boolean;
+}
+declare function avatarSvg(face: AvatarFace, options: AvatarDrawOptions): string;
+declare function avatarSvgUri(svg: string): string;
+
+type AvatarRenderKind = "portrait" | "bust" | "pin";
+type AvatarRenderStatus = "idle" | "loading" | "ready" | "pending" | "failed";
+interface AvatarRenderState {
+    readonly status: AvatarRenderStatus;
+    readonly src: string | null;
+}
+declare const RENDER_SIZES: readonly number[];
+declare const RENDER_PENDING_HEADER = "x-avatar-render";
+declare const RENDER_PENDING_VALUE = "pending";
+declare const RENDER_PENDING_RETRY_MS = 5000;
+declare const RENDER_PENDING_TRIES = 6;
+declare const MAX_KEPT_RENDERS = 256;
+interface RenderLoaderPorts {
+    readonly fetch: (url: string) => Promise<Response>;
+    readonly objectUrl: (blob: Blob) => string;
+    readonly revoke: (url: string) => void;
+    readonly later: (run: () => void, ms: number) => void;
+}
+declare class AvatarRenderCache {
+    private readonly states;
+    private readonly tries;
+    private readonly listeners;
+    private ports;
+    constructor(ports?: RenderLoaderPorts | null);
+    readonly subscribe: (listener: () => void) => (() => void);
+    state(url: string | null): AvatarRenderState;
+    request(url: string): void;
+    clear(): void;
+    private load;
+    private pending;
+    private set;
+    private notify;
+}
+declare const avatarRenders: AvatarRenderCache;
+declare function renderSize(size: number, pixelRatio?: number): number;
+declare function avatarRenderUrl(source: Pick<AvatarSource, "hash">, apiBase: string, options: {
+    readonly style: AvatarDrawStyle;
+    readonly size: number;
+    readonly kind?: AvatarRenderKind;
+    readonly pixelRatio?: number;
+}): string | null;
+declare function drawnAvatarUri(source: AvatarSource, options: AvatarDrawOptions): string | null;
+
+export { type AvatarDrawOptions, type AvatarDrawStyle, type AvatarFace, type AvatarLookItem, type AvatarPose, type AvatarRecordLike, AvatarRenderCache, type AvatarRenderKind, type AvatarRenderState, type AvatarRenderStatus, type AvatarSource, type HairShape, MAX_KEPT_RENDERS, RENDER_PENDING_HEADER, RENDER_PENDING_RETRY_MS, RENDER_PENDING_TRIES, RENDER_PENDING_VALUE, RENDER_SIZES, type RenderLoaderPorts, avatarFace, avatarFaceOf, avatarRenderUrl, avatarRenders, avatarSvg, avatarSvgUri, base64Bytes, drawnAvatarUri, renderSize, sourceOfRecord, stableHash };

package/dist/avatars.js

@@ -0,0 +1,82 @@
+'use strict';
+
+var chunkTWM6DLYF_js = require('./chunk-TWM6DLYF.js');
+var chunkAHNR3BXI_js = require('./chunk-AHNR3BXI.js');
+require('./chunk-MEXP6DA6.js');
+require('./chunk-PQTQKNKD.js');
+require('./chunk-JGBCIKJV.js');
+
+
+
+Object.defineProperty(exports, "AvatarRenderCache", {
+  enumerable: true,
+  get: function () { return chunkTWM6DLYF_js.AvatarRenderCache; }
+});
+Object.defineProperty(exports, "MAX_KEPT_RENDERS", {
+  enumerable: true,
+  get: function () { return chunkTWM6DLYF_js.MAX_KEPT_RENDERS; }
+});
+Object.defineProperty(exports, "RENDER_PENDING_HEADER", {
+  enumerable: true,
+  get: function () { return chunkTWM6DLYF_js.RENDER_PENDING_HEADER; }
+});
+Object.defineProperty(exports, "RENDER_PENDING_RETRY_MS", {
+  enumerable: true,
+  get: function () { return chunkTWM6DLYF_js.RENDER_PENDING_RETRY_MS; }
+});
+Object.defineProperty(exports, "RENDER_PENDING_TRIES", {
+  enumerable: true,
+  get: function () { return chunkTWM6DLYF_js.RENDER_PENDING_TRIES; }
+});
+Object.defineProperty(exports, "RENDER_PENDING_VALUE", {
+  enumerable: true,
+  get: function () { return chunkTWM6DLYF_js.RENDER_PENDING_VALUE; }
+});
+Object.defineProperty(exports, "RENDER_SIZES", {
+  enumerable: true,
+  get: function () { return chunkTWM6DLYF_js.RENDER_SIZES; }
+});
+Object.defineProperty(exports, "avatarRenderUrl", {
+  enumerable: true,
+  get: function () { return chunkTWM6DLYF_js.avatarRenderUrl; }
+});
+Object.defineProperty(exports, "avatarRenders", {
+  enumerable: true,
+  get: function () { return chunkTWM6DLYF_js.avatarRenders; }
+});
+Object.defineProperty(exports, "avatarSvg", {
+  enumerable: true,
+  get: function () { return chunkTWM6DLYF_js.avatarSvg; }
+});
+Object.defineProperty(exports, "avatarSvgUri", {
+  enumerable: true,
+  get: function () { return chunkTWM6DLYF_js.avatarSvgUri; }
+});
+Object.defineProperty(exports, "drawnAvatarUri", {
+  enumerable: true,
+  get: function () { return chunkTWM6DLYF_js.drawnAvatarUri; }
+});
+Object.defineProperty(exports, "renderSize", {
+  enumerable: true,
+  get: function () { return chunkTWM6DLYF_js.renderSize; }
+});
+Object.defineProperty(exports, "avatarFace", {
+  enumerable: true,
+  get: function () { return chunkAHNR3BXI_js.avatarFace; }
+});
+Object.defineProperty(exports, "avatarFaceOf", {
+  enumerable: true,
+  get: function () { return chunkAHNR3BXI_js.avatarFaceOf; }
+});
+Object.defineProperty(exports, "base64Bytes", {
+  enumerable: true,
+  get: function () { return chunkAHNR3BXI_js.base64Bytes; }
+});
+Object.defineProperty(exports, "sourceOfRecord", {
+  enumerable: true,
+  get: function () { return chunkAHNR3BXI_js.sourceOfRecord; }
+});
+Object.defineProperty(exports, "stableHash", {
+  enumerable: true,
+  get: function () { return chunkAHNR3BXI_js.stableHash; }
+});

package/dist/avatars.mjs

@@ -0,0 +1,5 @@
+export { AvatarRenderCache, MAX_KEPT_RENDERS, RENDER_PENDING_HEADER, RENDER_PENDING_RETRY_MS, RENDER_PENDING_TRIES, RENDER_PENDING_VALUE, RENDER_SIZES, avatarRenderUrl, avatarRenders, avatarSvg, avatarSvgUri, drawnAvatarUri, renderSize } from './chunk-6PJWXIFX.mjs';
+export { avatarFace, avatarFaceOf, base64Bytes, sourceOfRecord, stableHash } from './chunk-Z3A3AFVU.mjs';
+import './chunk-JKGTBMU7.mjs';
+import './chunk-XD2PMH46.mjs';
+import './chunk-25T4JHEA.mjs';