@wasm-gaming/rsdkv3-wasm 0.1.4 → 0.2.0

package/dist/rsdkv3/engine-specs.js

@@ -0,0 +1,382 @@
+// ---- Introspectable property definitions ----
+/**
+ * The listener bookkeeping, shipped rather than described — the one piece of runtime
+ * code in this package.
+ *
+ * It is a **convenience, not a requirement**: the contract stays structural, so an
+ * engine that already owns an emitter satisfies {@link EngineSurface} without this.
+ * What it saves is the part everyone gets subtly wrong — iterating a copy, so a
+ * listener that unsubscribes mid-emit does not corrupt the loop; de-duplicating a
+ * listener registered twice; and keeping one throwing listener from silencing the
+ * rest.
+ *
+ * Hold it **privately** and hand the same instance to every carrier. That is what
+ * makes `sdk.on(…)` and `play.on(…)` one channel rather than two, lets a host
+ * subscribe before the engine exists, and keeps `emit` out of the public API — a host
+ * must not be able to forge an engine event.
+ */
+export class EventEmitter {
+    #listeners = new Map();
+    /** @param listeners Registered immediately — what `EngineInit.on` carries. */
+    constructor(listeners) {
+        for (const type of Object.keys(listeners ?? {})) {
+            const listener = listeners?.[type];
+            if (listener)
+                this.on(type, listener);
+        }
+    }
+    /** Registering the same listener twice registers it once, as `EventTarget` does. */
+    on(type, listener) {
+        let set = this.#listeners.get(type);
+        if (!set)
+            this.#listeners.set(type, (set = new Set()));
+        set.add(listener);
+        return this;
+    }
+    /**
+     * The listener is required, as in `EventTarget`. A convenience `off(type)` dropping
+     * every listener for a type is a footgun on a page where two components subscribed
+     * independently: one unsubscribing would silence the other.
+     */
+    off(type, listener) {
+        const set = this.#listeners.get(type);
+        if (set?.delete(listener) && set.size === 0) {
+            this.#listeners.delete(type);
+        }
+        return this;
+    }
+    /**
+     * Takes the **detail**, and wraps it. The rest tuple is what lets an event with no
+     * detail be emitted as `emit('exit')` while still checking the ones that have one.
+     */
+    emit(type, ...[detail]) {
+        const set = this.#listeners.get(type);
+        if (!set)
+            return;
+        // Built once and frozen: every listener gets this same object, so a mutable one
+        // would let the first rewrite what the rest read.
+        const event = Object.freeze({ type, detail: detail });
+        // A copy: a listener may call `off()` — on itself or another — while this runs.
+        for (const listener of [...set]) {
+            try {
+                listener(event);
+            }
+            catch (thrown) {
+                // One bad listener must neither silence the rest nor vanish. Rethrowing on a
+                // fresh task puts it in front of `window.onerror` with its stack intact.
+                queueMicrotask(() => {
+                    throw thrown;
+                });
+            }
+        }
+    }
+}
+/**
+ * Wrap a promise of a live engine in the chainable surface.
+ *
+ * Exported because it is the single most duplicated function in an engine, and an
+ * engine that does not extend {@link EnginePlayBase} still needs exactly this.
+ *
+ * `on` and `off` do **not** go through the chain: they reach the channel now, so a
+ * listener is live before the promise settles. Routing them through it would bind
+ * after the session opened and lose whatever was emitted while it was opening.
+ */
+export function hydratePlay(inner, events) {
+    const chain = (step) => hydratePlay(inner.then(async (play) => {
+        await step(play);
+        return play;
+    }), events);
+    const hydrated = {
+        then: (onfulfilled, onrejected) => inner.then(onfulfilled, onrejected),
+        catch: (onrejected) => inner.catch(onrejected),
+        finally: (onfinally) => inner.finally(onfinally),
+        [Symbol.toStringTag]: 'PromisePlay',
+        config: ((patch) => patch === undefined
+            ? inner.then((play) => play.config())
+            : chain((play) => play.config(patch))),
+        options: ((patch) => patch === undefined
+            ? inner.then((play) => play.options())
+            : chain((play) => play.options(patch))),
+        assets: ((patch) => patch === undefined
+            ? inner.then((play) => play.assets())
+            : chain((play) => play.assets(patch))),
+        storage: ((patch) => patch === undefined
+            ? inner.then((play) => play.storage())
+            : chain((play) => play.storage(patch))),
+        mount: (target) => chain((play) => play.mount(target)),
+        on: (type, listener) => {
+            events.on(type, listener);
+            return hydrated;
+        },
+        off: (type, listener) => {
+            events.off(type, listener);
+            return hydrated;
+        },
+        restart: (options) => chain((play) => play.restart(options)),
+        destroy: () => inner.then((play) => play.destroy()),
+    };
+    return hydrated;
+}
+/**
+ * The live engine, with everything the contract prescribes already written: state,
+ * the cumulative merge, the descriptors, the chainable promise, and the channel.
+ *
+ * A subclass supplies what only it can know — {@link EnginePlayBase.open} and
+ * {@link EnginePlayBase.close}, optionally {@link EnginePlayBase.mounted} and
+ * {@link EnginePlayBase.patched} — and its properties as an {@link EngineSpec}.
+ *
+ * The spec arrives as a **constructor argument**, not an abstract field, and that is
+ * not a style choice: a subclass field initialiser runs *after* `super()`, so a
+ * `protected abstract spec` would still be `undefined` while this constructor seeded
+ * state from it. Passing it up makes the ordering trap impossible rather than merely
+ * avoided.
+ */
+export class EnginePlayBase {
+    #spec;
+    #state;
+    #events;
+    #target;
+    /** The target {@link EnginePlayBase.mounted} has already been told about. */
+    #attached;
+    /**
+     * @param events The factory's channel. Omitted only when a play is built on its
+     * own; the factory always passes its own, which is what makes `sdk.on(…)` and
+     * `play.on(…)` one channel rather than two.
+     */
+    constructor(spec, init, events) {
+        this.#spec = spec;
+        this.#events = events ?? new EventEmitter(init?.on);
+        this.#state = {
+            config: seed(spec.config, init?.config),
+            options: seed(spec.options, init?.options),
+            assets: seed(spec.assets, init?.assets),
+            storage: seed(spec.storage, init?.storage),
+        };
+        // Recorded, not applied. `mounted()` is overridable, and a subclass's own fields
+        // are still uninitialised while this constructor runs — so the hook is deferred to
+        // the first `restart()`, by which point the subclass is whole.
+        this.#target = init?.mount;
+    }
+    /** The element is already recorded when this runs. */
+    mounted(target) {
+        void target;
+    }
+    /** A payload changed on a running engine — apply what is `live`, ignore the rest. */
+    patched(kind, patch) {
+        void kind;
+        void patch;
+    }
+    /**
+     * Emit one of this engine's own events.
+     *
+     * `protected`, so a typed host cannot forge an engine event — but be exact about
+     * what that buys: TypeScript erases `protected`, so this is a compile-time guard,
+     * not a capability boundary. Plain JavaScript can still reach it. Only the `#`
+     * fields below — the channel and the state — are unreachable at runtime.
+     */
+    emit(type, ...detail) {
+        this.#events.emit(type, ...detail);
+    }
+    /** Where the picture is, for a subclass that needs the element after `mounted()`. */
+    get target() {
+        return this.#target;
+    }
+    config(patch) {
+        // `arguments.length`, not `patch === undefined`: `config(undefined)` is a write of
+        // nothing, not a read.
+        if (arguments.length === 0)
+            return Promise.resolve(this.#describe('config'));
+        return this.#patch('config', patch);
+    }
+    options(patch) {
+        if (arguments.length === 0)
+            return Promise.resolve(this.#describe('options'));
+        return this.#patch('options', patch);
+    }
+    assets(patch) {
+        if (arguments.length === 0)
+            return Promise.resolve(this.#describe('assets'));
+        return this.#patch('assets', patch);
+    }
+    storage(patch) {
+        if (arguments.length === 0)
+            return Promise.resolve(this.#describe('storage'));
+        return this.#patch('storage', patch);
+    }
+    mount(target) {
+        this.#target = target;
+        return this.#run(() => this.#attach());
+    }
+    on(type, listener) {
+        this.#events.on(type, listener);
+        return hydratePlay(Promise.resolve(this), this.#events);
+    }
+    off(type, listener) {
+        this.#events.off(type, listener);
+        return hydratePlay(Promise.resolve(this), this.#events);
+    }
+    restart(options) {
+        return this.#run(async () => {
+            if (options)
+                Object.assign(this.#state.options, options);
+            // A target supplied to the constructor lands here, which is what makes
+            // `new Sdk({ mount: el }).start()` and `new Sdk().mount(el).start()` the same
+            // call — the rule the contract states for everything on the surface.
+            await this.#attach();
+            const opened = { ...this.#state.options };
+            await this.open(opened);
+            this.#emitCore('start', opened);
+        });
+    }
+    async destroy() {
+        await this.#guard(async () => {
+            await this.close();
+            this.#target = undefined;
+            this.#attached = undefined;
+            this.#emitCore('exit', undefined);
+        });
+    }
+    /** Tell the engine where it is, once per distinct target. Reparenting is legal. */
+    async #attach() {
+        if (!this.#target || this.#target === this.#attached)
+            return;
+        this.#attached = this.#target;
+        await this.mounted(this.#target);
+    }
+    // ---- Shared machinery ----
+    /** One getter's answer: the spec, with the current value written into each entry. */
+    #describe(kind) {
+        const spec = this.#spec[kind];
+        const state = this.#state[kind];
+        const out = {};
+        for (const key of Object.keys(spec)) {
+            out[key] = { ...spec[key], value: state[key] };
+        }
+        return out;
+    }
+    /** Cumulative, merged flat, one level — `undefined` is a value, not "leave alone". */
+    #patch(kind, patch) {
+        Object.assign(this.#state[kind], patch);
+        return this.#run(async () => {
+            await this.patched(kind, patch ?? {});
+        });
+    }
+    /** A step, as a link in the chain — and as an `error` event if it throws. */
+    #run(step) {
+        return hydratePlay(this.#guard(step), this.#events);
+    }
+    /**
+     * The rule that errors reach a host **both ways**: the promise rejects *and*
+     * `error` is emitted. Written once here rather than at every throw site.
+     */
+    async #guard(step) {
+        try {
+            await step();
+            return this;
+        }
+        catch (thrown) {
+            const error = thrown instanceof Error ? thrown : new Error(String(thrown));
+            this.#emitCore('error', error);
+            throw error;
+        }
+    }
+    /**
+     * The core events, emitted from here rather than by a subclass.
+     *
+     * The cast is the one thing TypeScript will not check here: `emit` takes a rest
+     * tuple that is conditional on the detail type, and that conditional stays
+     * unresolved while `P` is still a type parameter. It is sound — `EventsOf<P>`
+     * always contains `CoreEvents<P>` by construction — and confining it to this one
+     * method is why the three call sites above read plainly.
+     */
+    #emitCore(type, detail) {
+        // Cast the channel, not the method: pulling `emit` out into a variable would call
+        // it unbound, and it reads its listeners off `this`.
+        const events = this.#events;
+        events.emit(type, detail);
+    }
+}
+/** Starting state: every `default` the spec declares, then whatever `init` overrides. */
+function seed(spec, patch) {
+    const state = {};
+    for (const [key, property] of Object.entries(spec)) {
+        if (property.default !== undefined)
+            state[key] = property.default;
+    }
+    return Object.assign(state, patch);
+}
+/**
+ * The factory, with everything the contract prescribes already written: the
+ * cumulative init, the synchronous chain, the channel that outlives every session,
+ * and one live engine per factory.
+ *
+ * A subclass supplies its static identity and {@link EngineSDKBase.createPlay}.
+ */
+export class EngineSDKBase {
+    #init;
+    #play;
+    /**
+     * Created before any engine exists and handed to every carrier downstream. That is
+     * what lets a host subscribe to an error thrown while the first session opens.
+     */
+    events;
+    constructor(init) {
+        this.#init = { ...init };
+        this.events = new EventEmitter(init?.on);
+    }
+    config(patch) {
+        if (arguments.length === 0)
+            return this.#pending().config();
+        return this.#patch('config', patch);
+    }
+    options(patch) {
+        if (arguments.length === 0)
+            return this.#pending().options();
+        return this.#patch('options', patch);
+    }
+    assets(patch) {
+        if (arguments.length === 0)
+            return this.#pending().assets();
+        return this.#patch('assets', patch);
+    }
+    storage(patch) {
+        if (arguments.length === 0)
+            return this.#pending().storage();
+        return this.#patch('storage', patch);
+    }
+    /** Recorded now, applied when the engine exists — same call as `new Sdk({ mount })`. */
+    mount(target) {
+        this.#init.mount = target;
+        this.#play?.mount(target);
+        return this;
+    }
+    on(type, listener) {
+        this.events.on(type, listener);
+        return this;
+    }
+    off(type, listener) {
+        this.events.off(type, listener);
+        return this;
+    }
+    /**
+     * The only way in. On a live engine it reopens the session rather than building a
+     * second one: a factory governs at most one engine.
+     */
+    start(options) {
+        this.#play ??= this.createPlay(this.#init, this.events);
+        return this.#play.restart(options);
+    }
+    /** Answers a read before there is an engine: the settings the next one will use. */
+    #pending() {
+        return this.#play ?? this.createPlay(this.#init, this.events);
+    }
+    #patch(kind, patch) {
+        this.#init[kind] = { ...this.#init[kind], ...patch };
+        // A live engine gets it too, so the factory does not silently describe a state
+        // the engine is not in.
+        if (this.#play && patch)
+            this.#play[kind](patch);
+        return this;
+    }
+}
+//# sourceMappingURL=engine-specs.js.map

package/dist/rsdkv3/rsdkv3.options.d.ts

@@ -1,22 +1,70 @@
-import type { JSONSchema } from '@wasm-gaming/engine-specs';
-export interface Rsdkv3Options {
-    /**
-     * RSDKv3's native in-canvas Dev Menu. Kept off by default: the launcher owns
-     * the debug/stage-select UI (via `instance.devMenu`), and leaving this on has
-     * historically produced a native menu-like screen at boot.
-     */
+/**
+ * What RSDKv3 accepts, as types and as data.
+ *
+ * The four payloads of the wasm-gaming engine contract, closed for this engine, and
+ * {@link RSDKV3_SPEC} — the same thing as data the contract's base class reads:
+ * every default lives there and nowhere else.
+ */
+import type { EnginePayloads, EngineSpec } from '@wasm-gaming/engine-specs';
+/** Bytes, or a thunk that produces them only when the engine actually needs them. */
+export type Rsdkv3Asset = Uint8Array | ArrayBuffer | null | (() => Uint8Array | ArrayBuffer | null | Promise<Uint8Array | ArrayBuffer | null>);
+/** The engine, written into the generated `settings.ini`. Fixed for the life of the wasm. */
+export interface Rsdkv3Config {
+    /** RSDKv3's native in-canvas Dev Menu. A host draws its own from `play.devMenu`. */
     devMenu?: boolean;
-    /** RSDKv3 EngineDebugMode — enables the web devmenu embind bridge hooks. */
+    /** RSDKv3 `EngineDebugMode`. */
     engineDebugMode?: boolean;
-    /** VSync setting in the generated settings.ini. */
     vsync?: boolean;
-    /** 0 = JP/EU soundtrack, 1 = US soundtrack. */
-    soundtrack?: number;
-    /** 0 = English. Matches RSDKv3 language numeric value. */
+    /** Sonic CD soundtrack: 0 = JP/EU, 1 = US. */
+    soundtrack?: 0 | 1;
+    /** RSDKv3 language index (0 = English). */
     language?: number;
-    /** Toggle touch controls in the generated settings.ini. */
     disableTouchControls?: boolean;
+    /** Emscripten glue URL. Defaults to `./rsdkv3.js` next to the SDK. */
+    jsUrl?: string;
+    /** WASM URL. Defaults to `./rsdkv3.wasm` next to the SDK. */
+    wasmUrl?: string;
+}
+/** The session. Nothing per-session yet. */
+export type Rsdkv3Options = Record<string, never>;
+export interface Rsdkv3Assets {
+    /** The game's `Data.rsdk` (Sonic CD). Required to start. */
+    data?: Rsdkv3Asset;
+    /** A ready-made `settings.ini`; omitted, one is generated from `config`. */
+    settings?: Rsdkv3Asset;
+}
+/** Where this engine's files live, and whether they outlive the page. */
+export interface Rsdkv3Storage {
+    /**
+     * Per-game folder, relative to the engine's own: files land in `rsdkv3/<namespace>/`
+     * (WASMFS `/data/rsdkv3/<namespace>`, and the OPFS folder the save is mirrored to).
+     * Segments are cleaned (`.`/`..` dropped, odd characters → `_`); a leading
+     * `rsdkv3/` is stripped once. `play.storagePath` gives the result.
+     *
+     * @defaultValue `"default"`
+     */
+    namespace?: string;
+    /** `null` keeps nothing; otherwise `SData.bin` is mirrored to OPFS. */
+    persist?: 'opfs' | null;
+}
+export interface Rsdkv3Events {
+    /** `SData.bin` changed and was written to `rsdkv3/<namespace>/`. */
+    saves: {
+        files: string[];
+    };
+}
+export interface Rsdkv3Payloads extends EnginePayloads {
+    config: Rsdkv3Config;
+    options: Rsdkv3Options;
+    assets: Rsdkv3Assets;
+    storage: Rsdkv3Storage;
+    events: Rsdkv3Events;
 }
-export declare const DEFAULT_RSDKV3_OPTIONS: Required<Rsdkv3Options>;
-export declare const RSDKV3_OPTIONS_SCHEMA: JSONSchema;
+/** The native picture, which the SDK scales to fit its mount. */
+export declare const RSDKV3_VIDEO: {
+    readonly width: 426;
+    readonly height: 240;
+    readonly aspect: "16:9";
+};
+export declare const RSDKV3_SPEC: EngineSpec<Rsdkv3Payloads>;
 //# sourceMappingURL=rsdkv3.options.d.ts.map

package/dist/rsdkv3/rsdkv3.options.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rsdkv3.options.d.ts","sourceRoot":"","sources":["../../src/rsdkv3.options.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAE5D,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,4EAA4E;IAC5E,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,mDAAmD;IACnD,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,+CAA+C;IAC/C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2DAA2D;IAC3D,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,aAAa,CAO1D,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,UA0BnC,CAAC"}
+{"version":3,"file":"rsdkv3.options.d.ts","sourceRoot":"","sources":["../../src/rsdkv3.options.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAE5E,qFAAqF;AACrF,MAAM,MAAM,WAAW,GACnB,UAAU,GACV,WAAW,GACX,IAAI,GACJ,CAAC,MAAM,UAAU,GAAG,WAAW,GAAG,IAAI,GAAG,OAAO,CAAC,UAAU,GAAG,WAAW,GAAG,IAAI,CAAC,CAAC,CAAC;AAEvF,6FAA6F;AAC7F,MAAM,WAAW,YAAY;IAC3B,oFAAoF;IACpF,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,gCAAgC;IAChC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,8CAA8C;IAC9C,UAAU,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;IACnB,2CAA2C;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,sEAAsE;IACtE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,6DAA6D;IAC7D,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,4CAA4C;AAC5C,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AAElD,MAAM,WAAW,YAAY;IAC3B,4DAA4D;IAC5D,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,WAAW,CAAC;CACxB;AAED,yEAAyE;AACzE,MAAM,WAAW,aAAa;IAC5B;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,uEAAuE;IACvE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB;AAED,MAAM,WAAW,YAAY;IAC3B,oEAAoE;IACpE,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;CAC5B;AAED,MAAM,WAAW,cAAe,SAAQ,cAAc;IACpD,MAAM,EAAE,YAAY,CAAC;IACrB,OAAO,EAAE,aAAa,CAAC;IACvB,MAAM,EAAE,YAAY,CAAC;IACrB,OAAO,EAAE,aAAa,CAAC;IACvB,MAAM,EAAE,YAAY,CAAC;CACtB;AAED,iEAAiE;AACjE,eAAO,MAAM,YAAY;;;;CAAuD,CAAC;AAEjF,eAAO,MAAM,WAAW,EAAE,UAAU,CAAC,cAAc,CAwClD,CAAC"}

package/dist/rsdkv3/rsdkv3.options.js

@@ -1,45 +1,44 @@
-// Engine-specific options for RSDKv3.
-//
-// This is the authoritative description of what `EngineConfig.options` accepts
-// for this engine. It provides both:
-//   - `Rsdkv3Options`          — compile-time type for TS hosts
-//   - `RSDKV3_OPTIONS_SCHEMA`  — JSON Schema mirrored into manifest.json
-//   - `DEFAULT_RSDKV3_OPTIONS` — defaults used when no settings.ini is supplied
-//
-// At runtime these options are serialized into Sonic CD's `settings.ini` format
-// when the host does not pass an explicit `settings` asset.
-export const DEFAULT_RSDKV3_OPTIONS = {
-    devMenu: false,
-    engineDebugMode: false,
-    vsync: false,
-    soundtrack: 0,
-    language: 0,
-    disableTouchControls: true,
-};
-export const RSDKV3_OPTIONS_SCHEMA = {
-    type: 'object',
-    additionalProperties: false,
-    properties: {
+/** The native picture, which the SDK scales to fit its mount. */
+export const RSDKV3_VIDEO = { width: 426, height: 240, aspect: '16:9' };
+export const RSDKV3_SPEC = {
+    config: {
         devMenu: {
-            type: 'boolean',
             default: false,
-            description: "RSDKv3's native in-canvas Dev Menu. The launcher provides its own overlay via instance.devMenu, so keep this off.",
+            live: false,
+            description: "RSDKv3's native Dev Menu; keep it off and draw your own from play.devMenu.",
         },
-        engineDebugMode: {
-            type: 'boolean',
-            default: false,
-            description: 'Enables the web devmenu embind bridge (stage list / warp / pause).',
+        engineDebugMode: { default: false, live: false, description: 'RSDKv3 EngineDebugMode.' },
+        vsync: { default: false, live: false, description: 'VSync in the generated settings.ini.' },
+        soundtrack: { default: 0, enum: [0, 1], live: false, description: 'Sonic CD soundtrack: 0 = JP/EU, 1 = US.' },
+        language: { default: 0, live: false, description: 'RSDKv3 language index (0 = English).' },
+        disableTouchControls: { default: true, live: false, description: 'Hide the touch controls.' },
+        jsUrl: { live: false, description: 'Emscripten glue URL. Defaults to ./rsdkv3.js.' },
+        wasmUrl: { live: false, description: 'WASM URL. Defaults to ./rsdkv3.wasm.' },
+    },
+    options: {},
+    assets: {
+        data: {
+            allowedTypes: ['.rsdk'],
+            live: false,
+            description: 'The RSDKv3 game data pack (Sonic CD). Required to start.',
+        },
+        settings: {
+            allowedTypes: ['.ini'],
+            live: false,
+            description: 'A ready-made settings.ini. Omitted, one is generated from config.',
+        },
+    },
+    storage: {
+        namespace: {
+            default: 'default',
+            live: false,
+            description: "Folder for this game's save, inside the engine's own rsdkv3/ folder (OPFS rsdkv3/<namespace>/).",
         },
-        vsync: { type: 'boolean', default: false },
-        soundtrack: {
-            type: 'integer',
-            minimum: 0,
-            maximum: 1,
-            default: 0,
-            description: 'Sonic CD soundtrack selector: 0=JP/EU, 1=US.',
+        persist: {
+            enum: ['opfs', null],
+            live: false,
+            description: 'null keeps nothing; otherwise SData.bin is mirrored to OPFS.',
         },
-        language: { type: 'integer', minimum: 0, default: 0 },
-        disableTouchControls: { type: 'boolean', default: true },
     },
 };
 //# sourceMappingURL=rsdkv3.options.js.map

package/dist/rsdkv3/rsdkv3.options.js.map

@@ -1 +1 @@
-{"version":3,"file":"rsdkv3.options.js","sourceRoot":"","sources":["../../src/rsdkv3.options.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC,EAAE;AACF,+EAA+E;AAC/E,qCAAqC;AACrC,gEAAgE;AAChE,yEAAyE;AACzE,gFAAgF;AAChF,EAAE;AACF,gFAAgF;AAChF,4DAA4D;AAuB5D,MAAM,CAAC,MAAM,sBAAsB,GAA4B;IAC7D,OAAO,EAAE,KAAK;IACd,eAAe,EAAE,KAAK;IACtB,KAAK,EAAE,KAAK;IACZ,UAAU,EAAE,CAAC;IACb,QAAQ,EAAE,CAAC;IACX,oBAAoB,EAAE,IAAI;CAC3B,CAAC;AAEF,MAAM,CAAC,MAAM,qBAAqB,GAAe;IAC/C,IAAI,EAAE,QAAQ;IACd,oBAAoB,EAAE,KAAK;IAC3B,UAAU,EAAE;QACV,OAAO,EAAE;YACP,IAAI,EAAE,SAAS;YACf,OAAO,EAAE,KAAK;YACd,WAAW,EACT,mHAAmH;SACtH;QACD,eAAe,EAAE;YACf,IAAI,EAAE,SAAS;YACf,OAAO,EAAE,KAAK;YACd,WAAW,EAAE,oEAAoE;SAClF;QACD,KAAK,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE;QAC1C,UAAU,EAAE;YACV,IAAI,EAAE,SAAS;YACf,OAAO,EAAE,CAAC;YACV,OAAO,EAAE,CAAC;YACV,OAAO,EAAE,CAAC;YACV,WAAW,EAAE,8CAA8C;SAC5D;QACD,QAAQ,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE;QACrD,oBAAoB,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE;KACzD;CACF,CAAC"}
+{"version":3,"file":"rsdkv3.options.js","sourceRoot":"","sources":["../../src/rsdkv3.options.ts"],"names":[],"mappings":"AAwEA,iEAAiE;AACjE,MAAM,CAAC,MAAM,YAAY,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAW,CAAC;AAEjF,MAAM,CAAC,MAAM,WAAW,GAA+B;IACrD,MAAM,EAAE;QACN,OAAO,EAAE;YACP,OAAO,EAAE,KAAK;YACd,IAAI,EAAE,KAAK;YACX,WAAW,EAAE,4EAA4E;SAC1F;QACD,eAAe,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE,yBAAyB,EAAE;QACxF,KAAK,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE,sCAAsC,EAAE;QAC3F,UAAU,EAAE,EAAE,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE,yCAAyC,EAAE;QAC7G,QAAQ,EAAE,EAAE,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE,sCAAsC,EAAE;QAC1F,oBAAoB,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE,0BAA0B,EAAE;QAC7F,KAAK,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE,+CAA+C,EAAE;QACpF,OAAO,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE,sCAAsC,EAAE;KAC9E;IACD,OAAO,EAAE,EAAE;IACX,MAAM,EAAE;QACN,IAAI,EAAE;YACJ,YAAY,EAAE,CAAC,OAAO,CAAC;YACvB,IAAI,EAAE,KAAK;YACX,WAAW,EAAE,0DAA0D;SACxE;QACD,QAAQ,EAAE;YACR,YAAY,EAAE,CAAC,MAAM,CAAC;YACtB,IAAI,EAAE,KAAK;YACX,WAAW,EAAE,mEAAmE;SACjF;KACF;IACD,OAAO,EAAE;QACP,SAAS,EAAE;YACT,OAAO,EAAE,SAAS;YAClB,IAAI,EAAE,KAAK;YACX,WAAW,EAAE,iGAAiG;SAC/G;QACD,OAAO,EAAE;YACP,IAAI,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC;YACpB,IAAI,EAAE,KAAK;YACX,WAAW,EAAE,8DAA8D;SAC5E;KACF;CACF,CAAC"}