ugly-game 0.5.22 → 0.6.0

package/dist/index.d.ts

@@ -13,3 +13,8 @@ export * from './input/ControlHints';
 export * from './input/TouchControls';
 export * from './loop/pageState';
 export * from './loop/gameLoop';
+export * from './loop/layout';
+export * from './loop/controlBlock';
+export * from './loop/deltaRing';
+export * from './loop/simCore';
+export * from './loop/simHost';

package/dist/index.js

@@ -15,3 +15,10 @@ export * from './input/ControlHints';
 export * from './input/TouchControls';
 export * from './loop/pageState';
 export * from './loop/gameLoop';
+export * from './loop/layout';
+export * from './loop/controlBlock';
+export * from './loop/deltaRing';
+export * from './loop/simCore';
+export * from './loop/simHost';
+// NOTE: './loop/simHost.worker' is intentionally NOT in the barrel — it is a worker entry, imported directly as
+// 'ugly-game/loop/simHost.worker' by a game's own worker file, never into a main-thread bundle.

package/dist/loop/controlBlock.d.ts

@@ -0,0 +1,33 @@
+export declare const CTL_HEADER: {
+    readonly RUNNING: 0;
+    readonly PLAYING: 1;
+    readonly PAUSE_REQ: 2;
+    readonly PAUSED: 3;
+    readonly DIRTY: 4;
+    readonly UPS: 5;
+    readonly TICK: 6;
+    readonly TARGET_TICK: 7;
+    readonly COOP: 8;
+    readonly LATE: 9;
+};
+export declare function controlByteLength(scalarNames: readonly string[]): number;
+export type { ScalarCell } from './layout';
+import type { ScalarCell } from './layout';
+export interface ControlView<S extends string> {
+    running: boolean;
+    playing: boolean;
+    pauseReq: boolean;
+    paused: boolean;
+    dirty: boolean;
+    ups: number;
+    tick: number;
+    targetTick: number;
+    coop: boolean;
+    late: number;
+    scalar(name: S): ScalarCell;
+    raw(): Int32Array;
+    /** Spin-wait (bounded) until PAUSED reaches `target`; returns true if it did. Main-thread safe (no Atomics.wait). */
+    waitPaused(target: boolean, spinMax?: number): boolean;
+    notify(slot: number): void;
+}
+export declare function createControlView<S extends string>(buf: ArrayBufferLike, scalarNames: readonly S[]): ControlView<S>;

package/dist/loop/controlBlock.js

@@ -0,0 +1,121 @@
+// ─────────────────────────────────────────────────────────────────────────────
+// CONTROL BLOCK — the sim/render coordination channel: a small Int32Array (over the same SharedArrayBuffer family)
+// with a FIXED header (lifecycle + diagnostics + co-op lockstep) and a game-declared SCALAR-mirror region (worker-
+// owned JS-number scalars it publishes for the main thread to read). Everything is accessed through typed named
+// getters/setters backed by Atomics — consumers never touch a raw slot index, so a wrong field is a compile error.
+// ─────────────────────────────────────────────────────────────────────────────
+export const CTL_HEADER = {
+    RUNNING: 0,
+    PLAYING: 1,
+    PAUSE_REQ: 2,
+    PAUSED: 3,
+    DIRTY: 4,
+    UPS: 5,
+    TICK: 6,
+    TARGET_TICK: 7,
+    COOP: 8,
+    LATE: 9,
+};
+const HEADER_LEN = 10;
+export function controlByteLength(scalarNames) {
+    return (HEADER_LEN + scalarNames.length) * 4;
+}
+export function createControlView(buf, scalarNames) {
+    const a = new Int32Array(buf);
+    const idx = new Map();
+    scalarNames.forEach((n, i) => idx.set(n, HEADER_LEN + i));
+    const b = (slot) => Atomics.load(a, slot) === 1;
+    const setb = (slot, v) => {
+        Atomics.store(a, slot, v ? 1 : 0);
+    };
+    const n = (slot) => Atomics.load(a, slot);
+    const setn = (slot, v) => {
+        Atomics.store(a, slot, v | 0);
+    };
+    const H = CTL_HEADER;
+    return {
+        get running() {
+            return b(H.RUNNING);
+        },
+        set running(v) {
+            setb(H.RUNNING, v);
+        },
+        get playing() {
+            return b(H.PLAYING);
+        },
+        set playing(v) {
+            setb(H.PLAYING, v);
+        },
+        get pauseReq() {
+            return b(H.PAUSE_REQ);
+        },
+        set pauseReq(v) {
+            setb(H.PAUSE_REQ, v);
+        },
+        get paused() {
+            return b(H.PAUSED);
+        },
+        set paused(v) {
+            setb(H.PAUSED, v);
+        },
+        get dirty() {
+            return b(H.DIRTY);
+        },
+        set dirty(v) {
+            setb(H.DIRTY, v);
+        },
+        get ups() {
+            return n(H.UPS);
+        },
+        set ups(v) {
+            setn(H.UPS, v);
+        },
+        get tick() {
+            return n(H.TICK);
+        },
+        set tick(v) {
+            setn(H.TICK, v);
+        },
+        get targetTick() {
+            return n(H.TARGET_TICK);
+        },
+        set targetTick(v) {
+            setn(H.TARGET_TICK, v);
+        },
+        get coop() {
+            return b(H.COOP);
+        },
+        set coop(v) {
+            setb(H.COOP, v);
+        },
+        get late() {
+            return n(H.LATE);
+        },
+        set late(v) {
+            setn(H.LATE, v);
+        },
+        scalar(name) {
+            const slot = idx.get(name);
+            if (slot === undefined) {
+                throw new Error(`[controlBlock] unknown scalar "${name}"`);
+            }
+            return {
+                get: () => Atomics.load(a, slot),
+                set: (v) => {
+                    Atomics.store(a, slot, v | 0);
+                },
+            };
+        },
+        raw: () => a,
+        waitPaused(target, spinMax = 8_000_000) {
+            let s = 0;
+            while (b(H.PAUSED) !== target && s++ < spinMax) {
+                /* spin — the worker flips PAUSED only between ticks */
+            }
+            return b(H.PAUSED) === target;
+        },
+        notify(slot) {
+            Atomics.notify(a, slot);
+        },
+    };
+}

package/dist/loop/deltaRing.d.ts

@@ -0,0 +1,19 @@
+export interface SideCodec<Entry> {
+    entryBytes: number;
+    encode(view: DataView, off: number, e: Entry): void;
+    decode(view: DataView, off: number): Entry;
+}
+export declare function ringByteLength(capacityEntries: number, entryBytes: number): number;
+export interface RingWriter<E> {
+    push(e: E): void;
+    seq(): number;
+}
+export declare function createRingWriter<E>(buf: ArrayBufferLike, codec: SideCodec<E>, capacityEntries: number): RingWriter<E>;
+export interface DrainResult {
+    drained: number;
+    overflowed: boolean;
+}
+export interface RingReader<E> {
+    drain(onEntry: (e: E) => void): DrainResult;
+}
+export declare function createRingReader<E>(buf: ArrayBufferLike, codec: SideCodec<E>, capacityEntries: number): RingReader<E>;

package/dist/loop/deltaRing.js

@@ -0,0 +1,48 @@
+// ─────────────────────────────────────────────────────────────────────────────
+// DELTA RING — a single-writer / single-reader versioned ring of FIXED-size entries over a shared buffer, for state
+// that isn't a fixed SAB column (chiefly a game's edit overlay). The sim thread `push`es a typed Entry (encoded via
+// a game-supplied SideCodec); the render thread `drain`s every entry appended since its last read. If the reader
+// fell more than `capacity` entries behind, that window is unrecoverable — `drain` reports `overflowed:true`, resets
+// itself to the writer head, and the caller requests a full resync. Header: [writeSeq:i32, _pad:i32] then entries.
+// ─────────────────────────────────────────────────────────────────────────────
+const HEADER_BYTES = 8; // writeSeq(i32) + pad(i32, keeps entries 8-aligned)
+export function ringByteLength(capacityEntries, entryBytes) {
+    return HEADER_BYTES + capacityEntries * entryBytes;
+}
+export function createRingWriter(buf, codec, capacityEntries) {
+    const head = new Int32Array(buf, 0, 2);
+    const view = new DataView(buf);
+    return {
+        push(e) {
+            const seq = Atomics.load(head, 0);
+            const slot = seq % capacityEntries;
+            codec.encode(view, HEADER_BYTES + slot * codec.entryBytes, e);
+            Atomics.store(head, 0, seq + 1); // publish AFTER the bytes are written
+        },
+        seq: () => Atomics.load(head, 0),
+    };
+}
+export function createRingReader(buf, codec, capacityEntries) {
+    const head = new Int32Array(buf, 0, 2);
+    const view = new DataView(buf);
+    let readSeq = Atomics.load(head, 0); // start at current head — pre-existing entries aren't "new"
+    return {
+        drain(onEntry) {
+            const writeSeq = Atomics.load(head, 0);
+            let overflowed = false;
+            let from = readSeq;
+            if (writeSeq - from > capacityEntries) {
+                overflowed = true;
+                from = writeSeq - capacityEntries; // only the newest `capacity` entries survive
+            }
+            let drained = 0;
+            for (let s = from; s < writeSeq; s++) {
+                const slot = s % capacityEntries;
+                onEntry(codec.decode(view, HEADER_BYTES + slot * codec.entryBytes));
+                drained++;
+            }
+            readSeq = writeSeq;
+            return { drained, overflowed };
+        },
+    };
+}

package/dist/loop/layout.d.ts

@@ -0,0 +1,37 @@
+type ArrayKind = 'f32' | 'f64' | 'i32' | 'u32' | 'u16' | 'u8' | 'i8';
+export interface ColumnSpec {
+    readonly _tag: 'field';
+    readonly kind: ArrayKind;
+    readonly len: number;
+}
+export interface ScalarSpec {
+    readonly _tag: 'scalar';
+    readonly kind: 'i32' | 'f64';
+}
+export interface LayoutSpec {
+    readonly [k: string]: ColumnSpec | ScalarSpec | LayoutSpec;
+}
+export declare const f32: (len: number) => ColumnSpec;
+export declare const f64: (len: number) => ColumnSpec;
+export declare const i32: (len: number) => ColumnSpec;
+export declare const u32: (len: number) => ColumnSpec;
+export declare const u16: (len: number) => ColumnSpec;
+export declare const u8: (len: number) => ColumnSpec;
+export declare const i8: (len: number) => ColumnSpec;
+export declare const scalarI32: () => ScalarSpec;
+export declare const scalarF64: () => ScalarSpec;
+export interface ScalarCell {
+    get(): number;
+    set(v: number): void;
+}
+type ArrayOf<K extends ArrayKind> = K extends 'f32' ? Float32Array : K extends 'f64' ? Float64Array : K extends 'i32' ? Int32Array : K extends 'u32' ? Uint32Array : K extends 'u16' ? Uint16Array : K extends 'u8' ? Uint8Array : Int8Array;
+type NodeOf<N> = N extends ColumnSpec ? ArrayOf<N['kind']> : N extends ScalarSpec ? ScalarCell : N extends LayoutSpec ? StateOf<N> : never;
+export type StateOf<Spec extends LayoutSpec> = {
+    [K in keyof Spec]: NodeOf<Spec[K]>;
+};
+export interface Layout<State> {
+    byteLength: number;
+    attach(buf: ArrayBufferLike): State;
+}
+export declare function defineLayout<Spec extends LayoutSpec>(spec: Spec): Layout<StateOf<Spec>>;
+export {};

package/dist/loop/layout.js

@@ -0,0 +1,97 @@
+// ─────────────────────────────────────────────────────────────────────────────
+// LAYOUT — a typed Structure-of-Arrays descriptor over ONE ArrayBuffer/SharedArrayBuffer. One `defineLayout(spec)`
+// call yields (a) a computed, 4-aligned `byteLength` and (b) `attach(buf)` that overlays typed-array columns + scalar
+// cells at those offsets, returning a view whose TYPE is inferred from the spec. Both the sim (worker) and render
+// (main) threads call `attach` on the same shared buffer, so they read the identical typed view — a field rename or
+// retype is a compile error on both sides. The byte→field binding itself is runtime (inherent to SAB); it is the one
+// tested seam (see layout.test.mts) rather than a compiler-proven fact.
+// ─────────────────────────────────────────────────────────────────────────────
+const field = (kind) => (len) => ({ _tag: 'field', kind, len });
+export const f32 = field('f32');
+export const f64 = field('f64');
+export const i32 = field('i32');
+export const u32 = field('u32');
+export const u16 = field('u16');
+export const u8 = field('u8');
+export const i8 = field('i8');
+export const scalarI32 = () => ({ _tag: 'scalar', kind: 'i32' });
+export const scalarF64 = () => ({ _tag: 'scalar', kind: 'f64' });
+const BYTES = {
+    f32: 4,
+    f64: 8,
+    i32: 4,
+    u32: 4,
+    u16: 2,
+    u8: 1,
+    i8: 1,
+};
+const CTOR = {
+    f32: Float32Array,
+    f64: Float64Array,
+    i32: Int32Array,
+    u32: Uint32Array,
+    u16: Uint16Array,
+    u8: Uint8Array,
+    i8: Int8Array,
+};
+const align = (o, a) => (o + (a - 1)) & ~(a - 1);
+function place(spec, start, out, path) {
+    let o = start;
+    for (const key of Object.keys(spec)) {
+        const node = spec[key];
+        const p = [...path, key];
+        if ('_tag' in node && node._tag === 'field') {
+            const b = BYTES[node.kind];
+            o = align(o, Math.max(4, b)); // 4-align every column so mixed widths stay aligned
+            out.set(p, { offset: o, spec: node });
+            o += node.len * b;
+        }
+        else if ('_tag' in node && node._tag === 'scalar') {
+            const b = node.kind === 'f64' ? 8 : 4;
+            o = align(o, b);
+            out.set(p, { offset: o, spec: node });
+            o += b;
+        }
+        else {
+            o = place(node, o, out, p); // nested
+        }
+    }
+    return o;
+}
+export function defineLayout(spec) {
+    const placed = new Map();
+    const byteLength = align(place(spec, 0, placed, []), 4);
+    return {
+        byteLength,
+        attach(buf) {
+            const root = {};
+            for (const [path, { offset, spec: s }] of placed) {
+                let cur = root;
+                for (let i = 0; i < path.length - 1; i++) {
+                    cur[path[i]] ??= {};
+                    cur = cur[path[i]];
+                }
+                const leaf = path[path.length - 1];
+                // Cast to ArrayBuffer for the typed-array ctors: TS 5.7 brands SharedArrayBuffer distinctly, but both are
+                // valid backing stores for a view at runtime (the whole point of a shared layout).
+                const ab = buf;
+                if (s._tag === 'field') {
+                    cur[leaf] = new CTOR[s.kind](ab, offset, s.len);
+                }
+                else {
+                    const arr = s.kind === 'f64'
+                        ? new Float64Array(ab, offset, 1)
+                        : new Int32Array(ab, offset, 1);
+                    const cell = {
+                        get: () => arr[0],
+                        set: (v) => {
+                            arr[0] = v;
+                        },
+                    };
+                    cur[leaf] = cell;
+                }
+            }
+            return root;
+        },
+    };
+}

package/dist/loop/simCore.d.ts

@@ -0,0 +1,19 @@
+import type { DeterministicSim } from '../moat';
+import type { ControlView } from './controlBlock';
+export interface SimClock {
+    now(): number;
+}
+export interface FixedStepOpts<S, I> {
+    sim: DeterministicSim<S, I>;
+    state: S;
+    ctl: ControlView<string>;
+    nextInput(): I | undefined;
+    clock: SimClock;
+    lastRef: {
+        t: number;
+    };
+    fps?: number;
+    maxCatchUpFrames?: number;
+    onScalars?(): void;
+}
+export declare function fixedStepBatch<S, I>(opts: FixedStepOpts<S, I>, acc: number): number;

package/dist/loop/simCore.js

@@ -0,0 +1,28 @@
+export function fixedStepBatch(opts, acc) {
+    const fps = opts.fps ?? 60;
+    const maxCatch = (opts.maxCatchUpFrames ?? 6) / fps; // seconds
+    const T = 1 / fps; // seconds/tick
+    const now = opts.clock.now();
+    const elapsed = Math.max(0, (now - opts.lastRef.t) / 1000);
+    opts.lastRef.t = now;
+    if (opts.ctl.pauseReq) {
+        opts.ctl.paused = true;
+        return 0; // drop the accumulator so we don't over-step on resume
+    }
+    opts.ctl.paused = false;
+    let a = Math.min(acc + elapsed, maxCatch); // clamp catch-up
+    let stepped = 0;
+    while (a >= T) {
+        const input = opts.nextInput();
+        opts.sim.step(opts.state, input); // step accepts the game's Input (undefined ⇒ the game's no-op input)
+        opts.ctl.tick = opts.ctl.tick + 1;
+        a -= T;
+        stepped++;
+    }
+    if (stepped > 0) {
+        const secs = Math.max(elapsed, T);
+        opts.ctl.ups = Math.round(stepped / secs) || opts.ctl.ups;
+        opts.onScalars?.();
+    }
+    return a;
+}

package/dist/loop/simHost.d.ts

@@ -0,0 +1,57 @@
+import type { Layout } from './layout';
+import { type ControlView } from './controlBlock';
+import { type SimClock } from './simCore';
+import type { DeterministicSim } from '../moat';
+import type { NetAdapter } from './gameLoop';
+export interface WorkerLike {
+    postMessage(m: unknown): void;
+    onmessage: ((e: {
+        data: unknown;
+    }) => void) | null;
+    terminate(): void;
+}
+export type HostToWorker<I> = {
+    t: 'init';
+    ctlBuf: ArrayBufferLike;
+    dataBuf: ArrayBufferLike;
+    scalars: readonly string[];
+    simFps: number;
+} | {
+    t: 'input';
+    v: I;
+} | {
+    t: 'resync-req';
+};
+export type WorkerToHost = {
+    t: 'ready';
+} | {
+    t: 'hash';
+    hash: string;
+} | {
+    t: 'cold';
+    payload: unknown;
+};
+export interface SimHostOpts<State, Input> {
+    layout: Layout<State>;
+    sim: DeterministicSim<State, Input>;
+    seed?: (s: State) => void;
+    scalars?: readonly string[];
+    worker?: () => WorkerLike;
+    clock?: SimClock;
+    simFps?: number;
+    maxCatchUpFrames?: number;
+    net?: NetAdapter;
+}
+export interface SimHost<State, Input> {
+    readonly state: State;
+    readonly available: boolean;
+    send(input: Input): void;
+    edit(fn: (s: State) => void): void;
+    ctl: ControlView<string>;
+    hash(): string;
+    netAdapter(): NetAdapter;
+    stop(): void;
+    /** Fallback/test only: advance the main-thread sim to wall time `nowMs`. Undefined when a worker owns stepping. */
+    pump?(nowMs: number): void;
+}
+export declare function createSimHost<State, Input>(opts: SimHostOpts<State, Input>): SimHost<State, Input>;

package/dist/loop/simHost.js

@@ -0,0 +1,104 @@
+import { createControlView, controlByteLength, } from './controlBlock';
+import { fixedStepBatch } from './simCore';
+const canSAB = () => typeof SharedArrayBuffer !== 'undefined' &&
+    (globalThis
+        .crossOriginIsolated ??
+        false);
+export function createSimHost(opts) {
+    const scalars = opts.scalars ?? [];
+    const useWorker = !!opts.worker && canSAB();
+    const dataBuf = useWorker
+        ? new SharedArrayBuffer(opts.layout.byteLength)
+        : new ArrayBuffer(opts.layout.byteLength);
+    const ctlBuf = useWorker
+        ? new SharedArrayBuffer(controlByteLength(scalars))
+        : new ArrayBuffer(controlByteLength(scalars));
+    const state = opts.layout.attach(dataBuf);
+    const ctl = createControlView(ctlBuf, scalars);
+    opts.seed?.(state);
+    const inputQ = [];
+    const clock = opts.clock ?? { now: () => Date.now() };
+    let lastHash = opts.sim.hash(state);
+    // ── Worker path ──────────────────────────────────────────────
+    let worker = null;
+    if (useWorker && opts.worker) {
+        worker = opts.worker();
+        worker.onmessage = (e) => {
+            const m = e.data;
+            if (m.t === 'hash')
+                lastHash = m.hash;
+        };
+        const init = {
+            t: 'init',
+            ctlBuf,
+            dataBuf,
+            scalars,
+            simFps: opts.simFps ?? 60,
+        };
+        worker.postMessage(init);
+        ctl.playing = true;
+    }
+    // ── Fallback path (main-thread stepping) ─────────────────────
+    const lastRef = { t: clock.now() };
+    let acc = 0;
+    const pump = (nowMs) => {
+        // The fallback clock is driven by the caller's timestamp for determinism in tests + frame-locked stepping.
+        const drivenClock = { now: () => nowMs };
+        acc = fixedStepBatch({
+            sim: opts.sim,
+            state,
+            ctl,
+            nextInput: () => inputQ.shift(),
+            clock: drivenClock,
+            lastRef,
+            fps: opts.simFps,
+            maxCatchUpFrames: opts.maxCatchUpFrames,
+        }, acc);
+        lastHash = opts.sim.hash(state);
+    };
+    // Solo default: nothing to catch up or resync (single-player). A co-op game passes its own NetAdapter.
+    const noop = () => undefined;
+    const net = opts.net ?? {
+        window: opts.maxCatchUpFrames ?? 6,
+        catchUp: noop,
+        resync: noop,
+    };
+    return {
+        state,
+        available: useWorker,
+        send(input) {
+            if (worker) {
+                const msg = { t: 'input', v: input };
+                worker.postMessage(msg);
+            }
+            else {
+                inputQ.push(input);
+            }
+        },
+        edit(fn) {
+            if (worker) {
+                ctl.pauseReq = true;
+                ctl.waitPaused(true);
+                try {
+                    fn(state);
+                }
+                finally {
+                    ctl.dirty = true;
+                    ctl.pauseReq = false;
+                    ctl.notify(2 /* PAUSE_REQ slot */);
+                }
+            }
+            else {
+                fn(state); // fallback: no concurrent stepping, apply directly
+            }
+        },
+        ctl,
+        hash: () => lastHash,
+        netAdapter: () => net,
+        stop() {
+            ctl.running = false;
+            worker?.terminate();
+        },
+        pump: useWorker ? undefined : pump,
+    };
+}

package/dist/loop/simHost.worker.d.ts

@@ -0,0 +1,8 @@
+import type { DeterministicSim } from '../moat';
+import type { Layout } from './layout';
+export interface SimWorkerConfig<S, I> {
+    sim: DeterministicSim<S, I>;
+    layout: Layout<S>;
+    makeInput?: (raw: unknown) => I;
+}
+export declare function runSimWorker<S, I>(cfg: SimWorkerConfig<S, I>): void;

package/dist/loop/simHost.worker.js

@@ -0,0 +1,55 @@
+import { createControlView } from './controlBlock';
+import { fixedStepBatch } from './simCore';
+export function runSimWorker(cfg) {
+    const ctx = globalThis;
+    const inputQ = [];
+    let state = null;
+    let ctl = null;
+    let acc = 0;
+    const clock = { now: () => performance.now() };
+    const lastRef = { t: 0 };
+    let fps = 60;
+    let upsCount = 0;
+    let upsWinStart = 0;
+    const loop = () => {
+        if (state && ctl?.running) {
+            const before = ctl.tick;
+            acc = fixedStepBatch({
+                sim: cfg.sim,
+                state,
+                ctl,
+                nextInput: () => inputQ.shift(),
+                clock,
+                lastRef,
+                fps,
+            }, acc);
+            const stepped = ctl.tick - before;
+            upsCount += stepped;
+            const now = clock.now();
+            if (upsWinStart === 0)
+                upsWinStart = now;
+            else if (now - upsWinStart >= 500) {
+                ctl.ups = Math.round((upsCount * 1000) / (now - upsWinStart));
+                upsCount = 0;
+                upsWinStart = now;
+            }
+            if (stepped > 0)
+                ctx.postMessage({ t: 'hash', hash: cfg.sim.hash(state) });
+        }
+        setTimeout(loop, 1);
+    };
+    ctx.onmessage = (e) => {
+        const m = e.data;
+        if (m.t === 'init') {
+            state = cfg.layout.attach(m.dataBuf);
+            ctl = createControlView(m.ctlBuf, m.scalars ?? []);
+            fps = m.simFps ?? 60;
+            ctl.running = true;
+            lastRef.t = clock.now();
+            loop();
+        }
+        else {
+            inputQ.push(cfg.makeInput ? cfg.makeInput(m.v) : m.v);
+        }
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ugly-game",
-  "version": "0.5.22",
+  "version": "0.6.0",
   "type": "module",
   "exports": {
     ".": {