@shieldbattery/broodmap 0.0.0-stage → 0.2.0

package/LICENSE-APACHE

@@ -0,0 +1,177 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS

package/LICENSE-MIT

@@ -0,0 +1,19 @@
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,236 @@
-# Temporary Holding Version
+# broodmap-wasm
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+WebAssembly bindings for rendering StarCraft: Brood War map previews in the browser (or Node):
+`MapRenderer` parses a map, names the assets it needs (the two-round prefetch API — asset keys
+are CASC catalog paths, which double as URL suffixes), accepts the fetched bytes, and renders
+previews, zero-asset minimaps, and render-plan JSON synchronously from memory.
+
+## Map summary
+
+`summarizeMapJson(mapBytes, options?)` reads a map's scenario facts without rendering anything or
+needing game assets, for listing and filtering map files cheaply. `options` is optional
+`MapLimitOptions` JSON overriding broodmap's default resource limits (`maxMapBytes`,
+`maxMpqFileBytes`, `maxChkBytes`, `maxMergedChunkBytes`), for callers that accept larger maps;
+`new MapRenderer(mapBytes, options?)` takes the same options. It returns `MapSummary` JSON (both
+types are in the package's TypeScript declarations):
+
+| Field | Meaning |
+| ----- | ------- |
+| `name`, `description` | Decoded scenario strings, color codes included. `null` when unset. |
+| `width`, `height`, `tileset` | Dimensions in tiles and the ERA tileset id. |
+| `stringEncoding` | How strings were decoded: `utf8`, `utf8-cp949`, `utf8-cp1252`, `cp949` or `cp1252`. |
+| `players` | The 8 player slots: `controller` (`OWNR` value), `race` (`SIDE` value) and `force` (force index; 4 or more means none). |
+| `forces` | The 4 forces' `name`s. |
+| `usesEud` | Whether triggers read or write memory outside the death table. |
+| `triggerActionKinds`, `triggerCount` | The distinct trigger action kinds used (names such as `CreateUnit`, sorted; empty `NoAction` slots don't count), and how many triggers there are. |
+| `placedUnits`, `playerUnits`, `startLocations` | Placed units (and those owned by one of the 8 player slots), not counting start locations, and the number of start locations. |
+
+It throws if the file isn't a readable map within those limits, or lacks the name, player or
+force sections. A `MapRenderer` gives the same JSON from `summaryJson()`, so a map that's also
+rendered is only parsed once.
+
+WebAssembly memory grows to fit the largest map parsed and never shrinks, so summarizing a folder
+of maps (especially with raised limits) keeps that much memory for the life of the module. Scan
+from a worker that can be terminated afterwards to give it back.
+
+## Package
+
+Published as `@shieldbattery/broodmap`, an ES module package built once with `wasm-pack --target
+web`. Browsers and bundlers get `pkg/broodmap_wasm.js` and must `await init()` before using it.
+Node gets `node-entry.js`, which loads the same build synchronously from disk, so it's ready on
+import (and `require()`, through Node's `require(esm)`); calling `init()` there is a harmless no-op.
+It needs Node 22.13.1 or later.
+
+`pnpm run build` builds `pkg/`; `pnpm run test:package` and `pnpm run test:types` check the built
+package through its entry points.
+
+## Browser example
+
+```bash
+pnpm install
+pnpm run assets:analysis # terrain tables and units.dat (~2.2 MB); minimap-backed analysis needs no artwork
+pnpm run assets   # fetch the style-complete SD asset set (~98 MB) into examples/assets
+                  # (uses a local SC:R install; add -- --cdn for no install)
+pnpm run dev      # build the wasm package and serve examples/ with vite
+```
+
+Pick a `.scm`/`.scx` map (e.g. `../broodmap/assets/lt.scm`) and render. The asset directory is
+produced by `broodmap-cli fetch-assets`, which writes files at exactly the paths the bindings
+request — any static file host works as an asset origin.
+
+## Node
+
+```bash
+pnpm run build
+node examples/node.mjs ../broodmap/assets/lt.scm examples/assets out.png
+```
+
+WASM renders are byte-identical to the native CLI's (verified against `broodmap-cli render`).
+
+### Reading a SC:R install
+
+Where the game install is readable synchronously (Node, Electron), `CascStorage` reads assets
+straight from its CASC storage, so no prefetch or extracted asset directory is needed:
+
+```js
+const storage = new CascStorage(files) // opens .build.info, indices and catalogs (~55 ms)
+const map = new MapRenderer(mapBytes)
+const missing = map.loadAssets(storage, opts) // art assets the install lacks; those degrade
+const png = map.renderPng(opts)
+```
+
+`files` is the sync file access broodcasc reads through, with paths relative to the install
+directory (the one containing `.build.info`): `open(path)` returns a handle, `size(handle)`,
+`read(handle, buffer, position)` returns the bytes read, `close(handle)`, and `listDir(path)`
+returns names (`[]` when the directory doesn't exist). `read` fills a view of WASM memory in
+place, so the callbacks mustn't call back into the module. `examples/casc-files.mjs` implements
+it over `node:fs`:
+
+```bash
+pnpm run build
+node examples/node-casc.mjs "C:/Program Files (x86)/StarCraft" ../broodmap/assets/lt.scm
+```
+
+Decoded assets are cached per `CascStorage` and shared by every map loaded from it (every render
+needs the ~38 MB `SD/mainSD.anim`). `new CascStorage(files, '{"cacheBytes": N}')` bounds the
+cache (default 128 MiB, about the whole `original`-style set). `storage.version` is the
+install's game version, for keying rendered-image caches. `free()` the storage to close its files.
+
+`pkg/` and `examples/assets/` are build/game-data artifacts and are gitignored;
+the assets are Blizzard's and must never be committed.
+
+## Terrain inspector (experimental)
+
+Choose a map and click **Analyze terrain**. That tileset's CV5/VF4 and the small `arr/units.dat` collision table are fetched.
+The inspector starts with a minimap backdrop; **Render** adds the full preview artwork.
+Toggle walkability, static obstacles, elevation, terrain buildability, or ramps; hover for cell attributes.
+**Respect map obstacles** is enabled by default; turn it off to compare terrain-only routes.
+Click two walkable cells to compare a ground route with the straight air-distance line.
+A third click starts a new route. Parsing, rendering, and routing run in a worker.
+
+Click **Find bases** to discover resource clusters and candidate depot footprints. Select **Base A**
+and **Base B**, then **Compare bases** for an orange ground route and dashed air-distance line.
+The obstacle toggle preserves base IDs and recomputes the selected comparison. Base labels include
+mineral/geyser counts and nearby start players; they do not assign main/natural roles.
+
+Discovery clusters resources by terrain connectivity and uses a stock 4x3 depot footprint.
+Candidate scoring accounts for static blockers and balances mineral and gas access. Sites marked
+`*` require clearing small mineral patches or overlapping buildings, highlighted in orange when
+selected. Exact start sites can clear overlapping objects automatically when occupied, including
+invincible ones. Current routes retain all these objects because this snapshot does not know the
+active starting assignments. Creep/power, full placement
+legality, and optimal gathering are not established. Small mineral groups may be omitted as bases,
+and qualifying clusters with no suitable site are reported.
+
+The routing model is an 8-pixel point grid with eight directions and no diagonal corner
+cutting. Resources and grounded neutral buildings from UNIT/THG2 block intersecting cells
+using caller-supplied units.dat collision bounds. It ignores moving units, mover sizes,
+and exact engine movement; narrow gaps can be overblocked. Turning obstacles off ignores
+all of them, including invincible buildings, rather than simulating their destruction. Ground distance uses fixed-point step costs (8 px orthogonal, 11.312 px diagonal),
+not travel time. Clicks snap to cell centers; distances use logical pixels, not output-image
+pixels (32 logical pixels = one map tile). Terrain buildability is a CV5 flag hint, not a
+building-placement validator. See [the analysis design](../docs/analysis-design.md).
+
+Existing terrain-only exports need `arr/units.dat` added. To refresh the small analysis tables:
+
+```bash
+pnpm run assets:analysis
+# Or just one map's tileset, from the repository root:
+cargo run -p broodmap-cli -- fetch-assets --analysis-only --out broodmap-wasm/examples/assets broodmap/assets/lt.scm
+```
+
+The usual `--install`, `--assets-dir`, and `--cdn` sources work with `--analysis-only`.
+Full `fetch-assets` bundles now include VF4 as well. Nothing is uploaded by the demo.
+
+Missing UNIT/THG2 chunks contribute no obstacles. The underlying parsers ignore incomplete
+trailing records; `obstacleCount` is not a map-integrity check. Definitions with negative
+collision extents are unsupported and skipped.
+
+The independent WASM snapshot can also be used outside the example:
+
+```js
+const [cv5Path, vf4Path, unitsPath] = map.requiredMapAnalysisAssets()
+const analysis = map.analyzeMap(
+  await fetchBytes(cv5Path), await fetchBytes(vf4Path), await fetchBytes(unitsPath),
+)
+// analysis.setObstaclesEnabled(false) selects terrain-only routes and clearance.
+const flags = analysis.cellFlags() // row-major; see generated TypeScript docs for bit layout
+const clearance = analysis.clearancePixels() // Uint16Array, row-major square radii in logical pixels
+// 0 = blocked; 4 = next to a blocker/map edge. Not unit passability or corridor width.
+const regions = analysis.analyzeRegions(32, 40) // minimum drop: 32 pixels AND 40% of peak radius
+try {
+  const labels = regions.labels() // owned Uint32Array; 0 blocked, region IDs start at 1
+  const graph = JSON.parse(regions.metadataJson()) // regions and representative passages
+} finally {
+  regions.free()
+}
+const route = JSON.parse(analysis.routeJson(10, 20, 30, 40)) // walk-cell coordinates
+// null groundDistancePixels means disconnected; invalid/blocked endpoints throw.
+const catalog = JSON.parse(analysis.findBasesJson('{}'))
+// Options: {depotWidthTiles:4,depotHeightTiles:3,maxMineralBlockerAmount:8}; unknown options throw.
+// Use maxMineralBlockerAmount:null, allowDestructibleClearing:false, and
+// allowStartObstacleClearing:false for strict current placement. See each base.requiredMinerals,
+// requiredObstacles, and startClearedObstacles.
+const bases = catalog.bases.filter(base => base.routeAnchor !== null)
+if (bases.length >= 2) {
+  const baseRoute = JSON.parse(analysis.baseRouteJson(bases[0].id, bases[1].id))
+  const [ax, ay] = bases[0].routeAnchor
+  const [bx, by] = bases[1].routeAnchor
+  const entrances = JSON.parse(analysis.entrancesJson(ax, ay, bx, by, 25))
+  // Batch multiple destinations per origin to share route searches; outputs keep query order.
+  const surveys = JSON.parse(analysis.entrancesBatchJson(JSON.stringify([
+    [[ax, ay], [bx, by]], [[bx, by], [ax, ay]],
+  ]), 25))
+  // Terrain-only survey from A toward B. Span endpoints are pixels; route points are walk cells.
+  // An outward width marked outwardWidthIsLowerBound is not an exact measured opening width.
+  const areas = analysis.partitionAreas(JSON.stringify(entrances.candidates.map(c => c.endpoints)))
+  try {
+    const labels = areas.labels() // every terrain-walkable cell keeps a positive component ID
+    const evidence = JSON.parse(areas.metadataJson()) // areas and effects of all supplied cuts
+  } finally {
+    areas.free()
+  }
+  // These virtual partition boundaries do not change ordinary routes or clearance regions.
+}
+analysis.free()
+```
+
+`requiredAnalysisAssets()` / `analyzeTerrain(cv5, vf4)` remain available for terrain-only callers.
+
+Select **Clearance** in the demo overlay menu to inspect narrow passages and open areas.
+Hover details include the numerical clearance radius with any overlay.
+The heatmap and hover radius follow **Respect map obstacles**. **Color scale maximum** defaults
+to 256px; choose a smaller range for tight gaps or a larger range for open areas. It changes
+only the colors, not the measured radii. Radius measures a centered,
+axis-aligned empty square and includes the map boundary; it is not an engine movement test.
+
+Use **Find regions** to color open-area partitions and mark candidate passages. Increase
+peak prominence or minimum relative narrowing to merge minor clearance peaks. Relative narrowing
+(default 40%) suppresses shallow splits in broad rooms, including those around resources.
+Base descriptions show their route anchor's region when available. Changing either threshold
+or obstacle mode clears the partition; run
+**Find regions** again to compare. Passage radii are square clearance values, not choke widths.
+
+After **Find bases**, select A and B and choose **Inspect entrances at A and B** to test the
+one-sided width detector in both directions. It searches the first 32 build tiles outward from
+each base along terrain-only survey routes. Labels A1/B1 identify the surveyed end, with widths
+and outward widening reported separately for each direction. Adjust **Minimum widening**
+to compare candidates. Region prominence settings do not affect this experiment. The detector
+can miss other exits and does not establish a sealed chokepoint or legal building wall.
+
+**Test base areas at A and B** also surveys each selected base's three nearest anchored bases.
+These connections are batched by origin. The terrain snapshot reuses prepared clearance and its
+original connected components across calls; changing maps creates a fresh snapshot.
+The public batch API accepts up to 256 queries, but each distinct origin can still require a
+full-grid search. The query/output limits are not a CPU budget; callers needing responsive
+cancellation should submit smaller origin groups and yield between synchronous calls.
+It closes the proposed crossings for an experimental terrain-only component flood and selects
+**Experimental base areas** in the overlay menu. Cyan/purple show the two selected components;
+amber means both bases remain in the same component. Green boundary lines separate components
+with all cuts applied; dashed amber lines retain bypassed crossings. The summary lists the known
+bases still connected inside each selected area. This local experiment can miss exits and does
+not alter normal routes, certify wallability, or replace the clearance region overlay.
+
+For a static demo build, run `pnpm run build:demo`. The output is `examples/dist/`.
+Game assets are not bundled: serve an exported asset directory separately and set the
+asset-base field to its URL (with CORS enabled when hosted on a different origin).

package/node-entry.js

@@ -0,0 +1,13 @@
+// The package's Node entry: the web build, initialized synchronously from disk so it can be used
+// as soon as it's imported (or required). Calling the default init export again is a no-op, so code
+// shared with the browser can still `await init()`.
+//
+// Not named node.js: cmd.exe looks in the current directory before PATH and .JS is in PATHEXT, so
+// a bare `node` in this package's scripts would open this file instead of running Node.
+import { readFileSync } from 'node:fs'
+import { initSync } from './pkg/broodmap_wasm.js'
+
+initSync({ module: readFileSync(new URL('./pkg/broodmap_wasm_bg.wasm', import.meta.url)) })
+
+export * from './pkg/broodmap_wasm.js'
+export { default } from './pkg/broodmap_wasm.js'

package/package.json

@@ -1,6 +1,56 @@
 {
   "name": "@shieldbattery/broodmap",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.0",
+  "type": "module",
+  "description": "WebAssembly bindings for broodmap: StarCraft: Brood War map summaries, previews and terrain analysis",
+  "main": "./node-entry.js",
+  "types": "./pkg/broodmap_wasm.d.ts",
+  "exports": {
+    ".": {
+      "types": "./pkg/broodmap_wasm.d.ts",
+      "node": "./node-entry.js",
+      "default": "./pkg/broodmap_wasm.js"
+    }
+  },
+  "files": [
+    "pkg/broodmap_wasm*",
+    "node-entry.js",
+    "LICENSE-APACHE",
+    "LICENSE-MIT"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=22.13.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ShieldBattery/broodmap.git",
+    "directory": "broodmap-wasm"
+  },
+  "keywords": [
+    "starcraft",
+    "map",
+    "parser",
+    "wasm",
+    "webassembly"
+  ],
+  "license": "MIT OR Apache-2.0",
+  "devDependencies": {
+    "typescript": "7.0.2",
+    "vite": "^8.3.5"
+  },
+  "scripts": {
+    "build": "wasm-pack build --target web --no-pack && node scripts/finalize-package.mjs",
+    "clean": "node -e \"require('node:fs').rmSync('pkg', { recursive: true, force: true })\"",
+    "assets:analysis": "cargo run --release -p broodmap-cli -- fetch-assets --analysis-only --out examples/assets",
+    "assets": "cargo run --release -p broodmap-cli -- fetch-assets --out examples/assets",
+    "dev": "pnpm run build && vite",
+    "build:demo": "pnpm run build && vite build",
+    "check:versions": "node scripts/check-versions.mjs",
+    "test": "pnpm run check:versions && node --test examples/*.test.mjs tests/topology-reference/*.test.mjs",
+    "test:package": "node --test scripts/package.test.mjs",
+    "test:types": "tsc --noEmit --strict --target ES2022 --module NodeNext --moduleResolution NodeNext scripts/types-consumer.ts && tsc --noEmit --strict --target ES2022 --module ESNext --moduleResolution Bundler scripts/types-consumer.ts"
+  }
 }