motely-wasm 19.1.1 → 19.3.1

package/README.md

@@ -1,8 +1,6 @@
 # motely-wasm
 
-WebAssembly package for [Motely](https://github.com/OptimusPi/MotelyJAML) — the Balatro seed search engine, with filters written in JAML.
-
-The package ships `jaml.schema.json` (JSON Schema for the JAML filter format) at the package root, so editors can wire it up for autocomplete / validation without an extra fetch.
+Balatro seed finder and per-seed analyzer, compiled to WebAssembly via [Bootsharp](https://bootsharp.com). Runs in browsers and Node/Deno/Bun.
 
 ## Install
 
@@ -10,255 +8,202 @@ The package ships `jaml.schema.json` (JSON Schema for the JAML filter format) at
 npm install motely-wasm
 ```
 
-## Quick start
-
-```js
-import bootsharp, { Motely } from "motely-wasm";
+## Module layout
 
-// Boot the .NET WASM runtime — no arguments needed.
-// The WASM binary is embedded in the package as base64 (single self-contained ESM).
-await bootsharp.boot();
+The root barrel (`motely-wasm`) re-exports only the Bootsharp runtime (`boot`, `getStatus`, `manifest`, …). The Motely API and enums live in generated submodules and **must be imported directly** via the package's subpath exports:
 
-// A JAML filter — see https://github.com/OptimusPi/MotelyJAML for the language.
-const jaml = `
-name: WeeMonday
-deck: Erratic
-stake: Black
-must:
-  - joker: WeeJoker
-    antes: [1]
-`;
-
-// Validate before searching — returns "valid" or an error message.
-const status = Motely.validateJaml(jaml);
-if (status !== "valid") throw new Error(status);
+```js
+import bootsharp from "motely-wasm";
+import { Program as Motely } from "motely-wasm/motely/wasm";
+import * as enums from "motely-wasm/motely/enums";
+```
 
-// One callback set per WASM load — subscribe after boot, before .start().
-Motely.onScoredResult.subscribe(r => console.log("match:", r.seed, r.score));
-Motely.onProgress.subscribe(p => console.log(`${p.percentComplete.toFixed(1)}%`));
+Additional submodules:
 
-const search = Motely.fromJaml(jaml).withSequentialSearch().start();
+| Specifier | Contents |
+|---|---|
+| `motely-wasm/motely/wasm` | `Program` — all search/analyze/JAML functions |
+| `motely-wasm/motely/enums` | `MotelyDeck`, `MotelyStake`, `MotelyBossBlind`, … |
+| `motely-wasm/motely/analysis` | `MotelyJamlyzerResult`, `MotelySeedAnalysis`, … |
+| `motely-wasm/motely/filters/jaml` | `JamlConfig`, `IJamlClause`, `JamlAesthetic` |
+| `motely-wasm/motely/filters` | `JamlSearchPlan` |
 
-await search.waitForCompletionAsync();
-console.log("done:", search.totalSeedsSearched, "searched,", search.matchingSeeds, "matched");
-```
+TypeScript types ship alongside each module as `.d.mts`.
 
-## Booting
+## Boot
 
-`bootsharp.boot()` initializes the .NET WASM runtime. Call it once before any `Motely.*` API.
+Binaries are sideloaded (published to `dist/bin/` as separate files). Pass the wasm bytes directly — `boot()` accepts either raw bytes or a URL root.
 
-The WASM binary is **embedded** in the package as base64 — no separate files to serve, no CDN config, no `bin/` directory. One import, one `boot()`, done. Works in browser, Node, Web Workers, v0 previews, MCP apps, GitHub Pages — anywhere.
+### Node
 
 ```js
+import { readFile } from "node:fs/promises";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
 import bootsharp from "motely-wasm";
+import { Program as Motely } from "motely-wasm/motely/wasm";
+import * as enums from "motely-wasm/motely/enums";
 
-if (bootsharp.getStatus() === bootsharp.BootStatus.Standby) {
-  await bootsharp.boot();
-}
+// [Import] callbacks must be assigned BEFORE boot.
+Motely.reportWasmError = (message) => console.error("[WASM ERROR]", message);
+Motely.jimmolateProbe = () => false; // required even when not using Jimmolate
 
-console.log(bootsharp.getStatus()); // BootStatus.Booted
+// import.meta.resolve("motely-wasm") → <pkg>/dist/index.mjs; dirname is already <pkg>/dist.
+const distDir = dirname(fileURLToPath(import.meta.resolve("motely-wasm")));
+const wasm = await readFile(resolve(distDir, "bin", bootsharp.manifest.wasm));
+await bootsharp.boot({ wasm });
 ```
 
-**Publish gate (repo):** after `dotnet publish Motely.Wasm -c Release`, run
-`node Motely.Wasm/motely.test.mjs` and `node Motely.Wasm/pack-consumer-smoke.mjs`.
-
-## JAML API
+### Browser
 
 ```js
-import { Motely } from "motely-wasm";
-
-// Validate a JAML filter string — returns "valid" on success, an error message on failure.
-const status = Motely.validateJaml(jaml);
-
-// Human-readable explanation of what a JAML filter does.
-const explanation = Motely.explainJaml(jaml);
-
-// Inspect the search plan (tally column count, CSV header, labels).
-const plan = Motely.createPlan(jaml);
+import bootsharp from "motely-wasm";
+import { Program as Motely } from "motely-wasm/motely/wasm";
 
-// Analyze specific seeds against a JAML filter.
-const result = Motely.analyzeJamlSeeds(jaml, ["ABCD1234", "XYZ99"]);
+Motely.reportWasmError = (message) => console.error("[WASM ERROR]", message);
+Motely.jimmolateProbe = () => false;
 
-// Engine version string.
-console.log(Motely.version());
+// Pass the URL root where dist/bin/ is served.
+await bootsharp.boot("/assets/motely-wasm/dist/bin");
 ```
 
-## JAML schema
+## Core API
 
-`motely-wasm` ships `jaml.schema.json` at the package root — point your editor at it for
-autocomplete and inline validation while writing filters:
+All methods are on the `Motely` (i.e. `Program`) namespace.
 
-```json
-{
-  "$schema": "node_modules/motely-wasm/jaml.schema.json"
-}
-```
-
-Or with a `# yaml-language-server` comment at the top of any `.jaml` / `.yml` filter file:
+### Parse a JAML filter
 
-```yaml
-# yaml-language-server: $schema=node_modules/motely-wasm/jaml.schema.json
-name: WeeMonday
-deck: Erratic
-stake: Black
+```js
+const cfg = Motely.parseJaml(`
+name: My Filter
+deck: Red
+stake: White
 must:
-  - joker: WeeJoker
-    antes: [1]
+  - joker: Triboulet
+    antes: [1, 2, 3]
+`);
 ```
 
-JAML is a YAML dialect (JSON-compatible). A filter is a flat document:
+`parseJaml` throws on invalid YAML. Use `jamlToJson` / `jsonToJaml` to convert between representations. Use `explainJaml` to get a human-readable summary of a parsed config.
 
-| Key | Purpose | Example |
-|---|---|---|
-| `name` | Human label | `WeeMonday` |
-| `deck` | Starting deck | `Erratic`, `Red`, `Ghost`, … |
-| `stake` | Difficulty floor | `White`, `Black`, `Gold`, … |
-| `must` | All clauses must match | list of clause objects |
-| `mustNot` | All clauses must NOT match | list of clause objects |
-| `should` | Scored clauses (use with `score:`) | list of clause objects |
+### Search
 
-Each clause object names a target type (`joker`, `tarot`, `planet`, `voucher`, `tag`, `boss`) plus
-optional filters (`antes`, `sources`, `min`, `score`):
+All `run*Search` methods return an `IMotelySearch` — call `.start()` then listen to events, or call `.runSearchUntilCompletion()` / `await .runSearchAsync()` for synchronous / async use.
 
-```yaml
-must:
-  - joker: WeeJoker          # specific item name, or "Any"
-    antes: [1, 2]            # which antes to check (omit = all)
-    sources:
-      shopItems: [0, 1]      # shop slot indices
-      boosterPacks: [0]      # pack slot indices
-  - tag: NegativeTag
-    antes: [1]
-  - voucher: Telescope
-    antes: [1, 2]
-    min: 2                   # appear at least N times across all listed antes
+```js
+// Subscribe to results before starting.
+Motely.onSeedMatch.subscribe((seed) => console.log("match:", seed));
+Motely.onProgress.subscribe((p) => console.log(`${p.percentComplete.toFixed(1)}%`));
+
+// Sequential: scan all seeds in batch range [0, 1).
+const search = Motely.runSequentialSearch(cfg, 0n, 1n);
+await search.runSearchAsync();
+
+// List: check specific seeds.
+cfg.seeds = ["PIFREAK1", "DEADBEEF"];
+const listSearch = Motely.runSeedListSearch(cfg);
+listSearch.runSearchUntilCompletion();
+console.log(listSearch.matchingSeeds); // bigint
+
+// Scored: emits onScoredResult instead of onSeedMatch.
+Motely.onScoredResult.subscribe((r) => console.log(r.seed, r.score));
+const scored = Motely.runSequentialSearch(cfg, 0n, 1n);
+await scored.runSearchAsync();
 ```
 
-Use `Motely.validateJaml(jaml)` to check a filter string at runtime; `Motely.explainJaml(jaml)`
-returns a human-readable plan; `Motely.createPlan(jaml)` returns the scoring structure.
+### Analyze a seed
 
-## Running a search
-
-Use `Motely.createSearchSettings()`, `Motely.createNativeSearchSettings(name)`, or
-`Motely.fromJaml(jaml)` — then chain modes. Callbacks are registered once per WASM load on `Motely`.
+`jamlyzer` runs the JAMLyzer on all seeds in `cfg.seeds` and returns per-ante detail: boss blind, voucher, tags, shop queue, booster packs.
 
 ```js
-import { Motely } from "motely-wasm";
-
-Motely.onSeedMatch.subscribe(seed => { /* … */ });
-Motely.onScoredResult.subscribe(r => { /* … */ });
-Motely.onProgress.subscribe(p => { /* … */ });
-
-const search = Motely.fromJaml(jaml).withSequentialSearch().start();
+cfg.seeds = ["PIFREAK1"];
+const result = Motely.jamlyzer(cfg);
+for (const { seed, analysis } of result.seeds) {
+    for (const ante of analysis.antes) {
+        console.log(`ante ${ante.ante} boss: ${enums.MotelyBossBlind[ante.boss]}`);
+        for (const { item, matched } of ante.shopQueue) {
+            console.log("  shop item", item.value, matched ? "(matched)" : "");
+        }
+    }
+}
+```
 
-// Async (yields between batches — good on the main thread or in a Worker)
-await search.waitForCompletionAsync();
+### Seed context (low-level)
 
-// or synchronous (blocks until done — only inside a Worker)
-// search.runSearchUntilCompletion();
+For custom logic, get a `MotelySingleSearchContext` and query PRNG streams directly:
 
-console.log(search.isCompleted, search.totalSeedsSearched, search.matchingSeeds);
-search.cancel(); // stop early
+```js
+const ctx = Motely.seedContext("PIFREAK1", enums.MotelyDeck.Red, enums.MotelyStake.White);
+const voucher = ctx.getAnteFirstVoucher(1);
+console.log("ante 1 voucher:", enums.MotelyVoucher[voucher]);
 ```
 
-## Events
+## Jimmolate
 
-Callbacks are registered on `Motely` once per `bootsharp.boot()` — not on each settings
-chain. Every search started from that WASM load shares the same handlers; run one search at
-a time or use separate worker boots if you need isolated callbacks.
+Jimmolate is a custom JS scalar predicate that runs on every seed that passes the base JAML filter. Wire it up and call `enableJimmolate()` after boot:
 
-| Event | Payload |
-|---|---|
-| `Motely.onSeedMatch` | `string` — matching seed |
-| `Motely.onScoredResult` | `{ seed, score, tallies }` |
-| `Motely.onProgress` | `MotelyProgress` — `percentComplete`, `seedsSearched`, `matchingSeeds`, `seedsPerMillisecond`, `elapsedMilliseconds` |
-| `Motely.onFileChanges` | `Change[]` — fires when files change under a directory mounted via `Motely.mountRoot` (browser File System Access API, requires `Bootsharp.FileSystem`). Ignore if your app doesn't mount local directories. |
+```js
+// Must be set BEFORE boot.
+Motely.jimmolateProbe = (ctx) => {
+    // ctx is MotelySingleSearchContext — same API as seedContext().
+    return ctx.getSeed().startsWith("PI");
+};
 
-Subscribe and unsubscribe:
+await bootsharp.boot({ wasm });
+Motely.enableJimmolate();
 
-```js
-const handler = r => console.log(r.seed);
-Motely.onScoredResult.subscribe(handler);
-Motely.onScoredResult.unsubscribe(handler);
+cfg.seeds = ["PIFREAK1", "XYZABCDE"];
+Motely.onSeedMatch.subscribe((s) => console.log("jimmolate match:", s));
+Motely.runPassthroughListSearch(cfg.seeds).runSearchUntilCompletion();
 ```
 
-## Submodule exports
+Use `runPassthroughListSearch` to skip the JAML filter entirely and let Jimmolate do all the culling.
 
-| Import path | Contents |
-|---|---|
-| `motely-wasm` | Default export: `boot`, `getStatus`, `BootStatus`. Named export: `Motely` (main API) |
-| `motely-wasm/motely` | `IMotelySearch`, `SearchSettings`, `MotelyProgress`, `MotelyScoredSeedResult`, `MotelyStreamKind` |
-| `motely-wasm/motely/enums` | All Balatro enums — `MotelyItemType`, `MotelyItemTypeCategory`, `MotelyJokerRarity`, `MotelyItemEdition`, `MotelyItemSeal`, `MotelyItemEnhancement`, `MotelyTag`, `MotelyVoucher`, `MotelyBoosterPack`, `MotelyDeck`, `MotelyStake`, `MotelyBossBlind`, etc. |
-| `motely-wasm/motely/filters` | `JamlAesthetic`, `JamlSearchPlan` |
-| `motely-wasm/motely/analysis` | `MotelyJamlyzerResult`, `MotelySeedAnalysis` |
-| `motely-wasm/bootsharp/file-system` | File-system interop (browser OPFS) — `PermissionMode`, `IFileMounter` |
+## JAML quick reference
 
-## Using in a Web Worker
+```yaml
+name: string          # optional display name
+deck: Red             # MotelyDeck value (case-insensitive)
+stake: White          # MotelyStake value
+seeds: []             # pre-populate for list searches
+
+must:                 # all clauses must match
+  - joker: Triboulet
+    antes: [1, 2]     # ante numbers (1–8)
+    min: 1            # default 1
+    max: 2            # optional upper bound
+
+should:               # scoring; doesn't filter, raises score
+  - voucher: Telescope
+    antes: [1, 2]
+    score: 10
 
-The WASM runtime is single-threaded. For a non-blocking UI, boot a runtime inside a
-Worker and drive it with messages. This mirrors the proven setup in the `jaml-ui`
-package's `searchWorker.ts`.
+mustNot:              # any match rejects the seed
+  - boss: TheHook
+    antes: [1]
+```
 
-```js
-// search-worker.js
-import bootsharp, { Motely } from "motely-wasm";
-
-let currentSearch = null;
-
-self.onmessage = async ({ data }) => {
-  if (data.type === "stop") {
-    currentSearch?.cancel();
-    self.postMessage({ type: "cancelled" });
-    return;
-  }
-  if (data.type !== "start") return;
-
-  try {
-    if (bootsharp.getStatus() === bootsharp.BootStatus.Standby) {
-      await bootsharp.boot();
-    }
+Clause types: `joker`, `voucher`, `boss`, `tag`, `spectral`, `tarot`, `planet`, `pack`.  
+Sources can be narrowed via `sources: { shopItems: [0, 1], boosterPacks: [0] }`.
 
-    const onResult = r =>
-      self.postMessage({ type: "result", seed: r.seed, score: r.score });
-    const onProgress = p =>
-      self.postMessage({ type: "progress", percent: p.percentComplete });
-    Motely.onScoredResult.subscribe(onResult);
-    Motely.onProgress.subscribe(onProgress);
-
-    try {
-      currentSearch = Motely.createSearch(data.jaml)
-        .withThreadCount(1)
-        .withSequentialSearch()
-        .start();
-      await currentSearch.waitForCompletionAsync();
-      self.postMessage({
-        type: "complete",
-        total: Number(currentSearch.totalSeedsSearched),
-        matched: Number(currentSearch.matchingSeeds),
-      });
-    } finally {
-      Motely.onScoredResult.unsubscribe(onResult);
-      Motely.onProgress.unsubscribe(onProgress);
-      currentSearch = null;
-    }
-  } catch (error) {
-    self.postMessage({ type: "error", message: String(error?.message ?? error) });
-  }
-};
+## Enums
 
-self.postMessage({ type: "ready" });
-```
+All enum values are available in the `enums` module:
+
+- `MotelyDeck` — Red, Blue, Yellow, Green, Black, Magic, Nebula, Ghost, Abandoned, Checkered, Zodiac, Painted, Anaglyph, Plasma, Erratic
+- `MotelyStake` — White, Red, Green, Black, Blue, Purple, Orange, Gold
+- `MotelyBossBlind`, `MotelyVoucher`, `MotelyTag`, `MotelyBoosterPack`
+
+## Utility
 
 ```js
-// main thread
-const worker = new Worker(new URL("./search-worker.js", import.meta.url), { type: "module" });
+// Convert between JAML text and JSON.
+const json = Motely.jamlToJson(jamlText);
+const jaml = Motely.jsonToJaml(json);
 
-worker.onmessage = ({ data }) => {
-  if (data.type === "result") console.log("match:", data.seed, data.score);
-  if (data.type === "progress") console.log(`${data.percent.toFixed(1)}%`);
-  if (data.type === "complete") console.log("done:", data.total, data.matched);
-};
+// Human-readable description of a parsed config.
+const explanation = Motely.explainJaml(cfg);
 
-worker.postMessage({ type: "start", jaml });
-// worker.postMessage({ type: "stop" }); // cancel early
+// List available native (non-JAML) filter names.
+const names = Motely.nativeFilterNames();
 ```

package/dist/bcl/cancellation.d.mts

@@ -1,14 +1,11 @@
 import { Event } from "./event.mjs";
-/** JavaScript counterpart of the C# <c>System.Threading.CancellationToken</c> specialization.
- *  Hand-rolled instances are constructed in user code and passed across the interop boundary;
- *  instances received from C# are wrapped into generated proxies that expose the same shape. */
+/** A cancellation token compatible with C# `CancellationToken`. */
 export declare class CancellationToken {
-    private cancelled;
-    /** Fires when the token is cancelled. */
+    /** Occurs when the token is cancelled. */
     readonly onCancellationRequested: Event<[]>;
     /** Whether cancellation has been requested. */
     get isCancellationRequested(): boolean;
-    /** Signal cancellation: flips <see cref="isCancellationRequested"/> and broadcasts
-     *  <see cref="onCancellationRequested"/>. Idempotent. */
+    private cancelled;
+    /** Signal cancellation. */
     cancel(): void;
 }

package/dist/bcl/cancellation.mjs

@@ -1,17 +1,12 @@
 import { Event } from "./event.mjs";
-/** JavaScript counterpart of the C# <c>System.Threading.CancellationToken</c> specialization.
- *  Hand-rolled instances are constructed in user code and passed across the interop boundary;
- *  instances received from C# are wrapped into generated proxies that expose the same shape. */
+/** A cancellation token compatible with C# `CancellationToken`. */
 export class CancellationToken {
-    cancelled = false;
-    /** Fires when the token is cancelled. */
+    /** Occurs when the token is cancelled. */
     onCancellationRequested = new Event();
     /** Whether cancellation has been requested. */
-    get isCancellationRequested() {
-        return this.cancelled;
-    }
-    /** Signal cancellation: flips <see cref="isCancellationRequested"/> and broadcasts
-     *  <see cref="onCancellationRequested"/>. Idempotent. */
+    get isCancellationRequested() { return this.cancelled; }
+    cancelled = false;
+    /** Signal cancellation. */
     cancel() {
         if (this.cancelled)
             return;

package/dist/bcl/collection.d.mts

@@ -1,7 +1,4 @@
-/** JavaScript counterpart of the C# <c>Bootsharp.Collection&lt;T&gt;</c> specialization of
- *  <c>System.Collections.Generic.ICollection&lt;T&gt;</c>. Hand-rolled instances are constructed in
- *  user code and passed across the interop boundary; instances received from C# are wrapped into
- *  generated proxies that expose the same shape. */
+/** A collection of items compatible with C# `ICollection<T>`. */
 export declare class Collection<T> {
     protected readonly items: T[];
     constructor(items?: Iterable<T>);

package/dist/bcl/collection.mjs

@@ -1,7 +1,4 @@
-/** JavaScript counterpart of the C# <c>Bootsharp.Collection&lt;T&gt;</c> specialization of
- *  <c>System.Collections.Generic.ICollection&lt;T&gt;</c>. Hand-rolled instances are constructed in
- *  user code and passed across the interop boundary; instances received from C# are wrapped into
- *  generated proxies that expose the same shape. */
+/** A collection of items compatible with C# `ICollection<T>`. */
 export class Collection {
     items;
     constructor(items) {

package/dist/bcl/dictionary.d.mts

@@ -0,0 +1,25 @@
+/** A dictionary of key-value pairs compatible with C# `IDictionary<TKey, TValue>`. */
+export declare class Dictionary<TKey, TValue> {
+    protected readonly map: Map<TKey, TValue>;
+    constructor(entries?: Iterable<[TKey, TValue]>);
+    /** Number of key-value pairs in the dictionary. */
+    get count(): number;
+    /** Associates the specified value with the specified key. */
+    add(key: TKey, value: TValue): void;
+    /** Whether the dictionary contains the specified key. */
+    containsKey(key: TKey): boolean;
+    /** Removes the value with the specified key from the dictionary.
+     *  @returns true when the key was removed; false when it wasn't found. */
+    remove(key: TKey): boolean;
+    /** Removes all key-value pairs from the dictionary. */
+    clear(): void;
+    /** Returns the value associated with the specified key. */
+    getAt(key: TKey): TValue;
+    /** Associates the specified value with the specified key. */
+    setAt(key: TKey, value: TValue): void;
+    /** Returns a fresh array with a snapshot of the current keys. */
+    getKeys(): TKey[];
+    /** Returns a fresh array with a snapshot of the current values. */
+    getValues(): TValue[];
+    [Symbol.iterator](): IterableIterator<[TKey, TValue]>;
+}

package/dist/bcl/dictionary.mjs

@@ -0,0 +1,47 @@
+/** A dictionary of key-value pairs compatible with C# `IDictionary<TKey, TValue>`. */
+export class Dictionary {
+    map;
+    constructor(entries) {
+        this.map = new Map(entries);
+    }
+    /** Number of key-value pairs in the dictionary. */
+    get count() {
+        return this.map.size;
+    }
+    /** Associates the specified value with the specified key. */
+    add(key, value) {
+        this.map.set(key, value);
+    }
+    /** Whether the dictionary contains the specified key. */
+    containsKey(key) {
+        return this.map.has(key);
+    }
+    /** Removes the value with the specified key from the dictionary.
+     *  @returns true when the key was removed; false when it wasn't found. */
+    remove(key) {
+        return this.map.delete(key);
+    }
+    /** Removes all key-value pairs from the dictionary. */
+    clear() {
+        this.map.clear();
+    }
+    /** Returns the value associated with the specified key. */
+    getAt(key) {
+        return this.map.get(key);
+    }
+    /** Associates the specified value with the specified key. */
+    setAt(key, value) {
+        this.map.set(key, value);
+    }
+    /** Returns a fresh array with a snapshot of the current keys. */
+    getKeys() {
+        return Array.from(this.map.keys());
+    }
+    /** Returns a fresh array with a snapshot of the current values. */
+    getValues() {
+        return Array.from(this.map.values());
+    }
+    [Symbol.iterator]() {
+        return this.map[Symbol.iterator]();
+    }
+}

package/dist/bcl/event.d.mts

@@ -20,7 +20,7 @@ export type EventOptions = {
     /** Custom warnings handler; by default <code>console.warn</code> is used. */
     warn?: (message: string) => void;
 };
-/** Allows attaching handlers and broadcasting events. */
+/** Allows attaching handlers and broadcasting events; compatible with C# events. */
 export declare class Event<T extends unknown[]> implements EventBroadcaster<T>, EventSubscriber<T> {
     private readonly handlers;
     private readonly warn;

package/dist/bcl/event.mjs

@@ -1,4 +1,4 @@
-/** Allows attaching handlers and broadcasting events. */
+/** Allows attaching handlers and broadcasting events; compatible with C# events. */
 export class Event {
     handlers = new Map();
     warn;

package/dist/bcl/index.d.mts

@@ -1,4 +1,5 @@
 export * from "./event.mjs";
 export * from "./collection.mjs";
 export * from "./list.mjs";
+export * from "./dictionary.mjs";
 export * from "./cancellation.mjs";

package/dist/bcl/index.mjs

@@ -1,4 +1,5 @@
 export * from "./event.mjs";
 export * from "./collection.mjs";
 export * from "./list.mjs";
+export * from "./dictionary.mjs";
 export * from "./cancellation.mjs";

package/dist/bcl/list.d.mts

@@ -1,17 +1,14 @@
 import { Collection } from "./collection.mjs";
-/** JavaScript counterpart of the C# <c>System.Collections.Generic.IList&lt;T&gt;</c> specialization.
- *  Extends <see cref="Collection"/> with index-based access; like the collection, hand-rolled
- *  instances are passed across the interop boundary, while instances received from C# are wrapped
- *  into generated proxies that expose the same shape. */
+/** A list of items compatible with C# `IList<T>`. */
 export declare class List<T> extends Collection<T> {
+    /** Returns the item at the specified index. */
+    getAt(index: number): T;
+    /** Assigns the specified item at the specified index. */
+    setAt(index: number, item: T): void;
     /** Returns the index of the first occurrence of the specified item, or -1 when not found. */
     indexOf(item: T): number;
     /** Inserts the specified item at the specified index. */
     insert(index: number, item: T): void;
     /** Removes the item at the specified index. */
     removeAt(index: number): void;
-    /** Returns the item at the specified index. */
-    getAt(index: number): T;
-    /** Assigns the specified item at the specified index. */
-    setAt(index: number, item: T): void;
 }

package/dist/bcl/list.mjs

@@ -1,9 +1,14 @@
 import { Collection } from "./collection.mjs";
-/** JavaScript counterpart of the C# <c>System.Collections.Generic.IList&lt;T&gt;</c> specialization.
- *  Extends <see cref="Collection"/> with index-based access; like the collection, hand-rolled
- *  instances are passed across the interop boundary, while instances received from C# are wrapped
- *  into generated proxies that expose the same shape. */
+/** A list of items compatible with C# `IList<T>`. */
 export class List extends Collection {
+    /** Returns the item at the specified index. */
+    getAt(index) {
+        return this.items[index];
+    }
+    /** Assigns the specified item at the specified index. */
+    setAt(index, item) {
+        this.items[index] = item;
+    }
     /** Returns the index of the first occurrence of the specified item, or -1 when not found. */
     indexOf(item) {
         return this.items.indexOf(item);
@@ -16,12 +21,4 @@ export class List extends Collection {
     removeAt(index) {
         this.items.splice(index, 1);
     }
-    /** Returns the item at the specified index. */
-    getAt(index) {
-        return this.items[index];
-    }
-    /** Assigns the specified item at the specified index. */
-    setAt(index, item) {
-        this.items[index] = item;
-    }
 }