@jsprismarine/structures 0.0.0 → 0.16.0-unstable-20261029135432

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (57) hide show
  1. package/CHANGELOG.md +109 -0
  2. package/LICENSE +373 -0
  3. package/README.md +219 -0
  4. package/dist/_virtual/_rolldown/runtime.cjs.cjs +23 -0
  5. package/dist/bedrockTemplate.cjs.cjs +144 -0
  6. package/dist/bedrockTemplate.d.ts +25 -0
  7. package/dist/bedrockTemplate.d.ts.map +1 -0
  8. package/dist/bedrockTemplate.es.js +137 -0
  9. package/dist/index.cjs.cjs +65 -0
  10. package/dist/index.d.ts +11 -0
  11. package/dist/index.d.ts.map +1 -0
  12. package/dist/index.es.js +11 -0
  13. package/dist/javaTemplate.cjs.cjs +106 -0
  14. package/dist/javaTemplate.d.ts +27 -0
  15. package/dist/javaTemplate.d.ts.map +1 -0
  16. package/dist/javaTemplate.es.js +100 -0
  17. package/dist/jigsaw.cjs.cjs +623 -0
  18. package/dist/jigsaw.d.ts +257 -0
  19. package/dist/jigsaw.d.ts.map +1 -0
  20. package/dist/jigsaw.es.js +609 -0
  21. package/dist/nbtAccess.cjs.cjs +86 -0
  22. package/dist/nbtAccess.d.ts +37 -0
  23. package/dist/nbtAccess.d.ts.map +1 -0
  24. package/dist/nbtAccess.es.js +74 -0
  25. package/dist/processors.cjs.cjs +559 -0
  26. package/dist/processors.d.ts +91 -0
  27. package/dist/processors.d.ts.map +1 -0
  28. package/dist/processors.es.js +550 -0
  29. package/dist/random.cjs.cjs +79 -0
  30. package/dist/random.d.ts +41 -0
  31. package/dist/random.d.ts.map +1 -0
  32. package/dist/random.es.js +75 -0
  33. package/dist/structureSets.cjs.cjs +214 -0
  34. package/dist/structureSets.d.ts +117 -0
  35. package/dist/structureSets.d.ts.map +1 -0
  36. package/dist/structureSets.es.js +205 -0
  37. package/dist/tableShape.cjs.cjs +14 -0
  38. package/dist/tableShape.d.ts +13 -0
  39. package/dist/tableShape.d.ts.map +1 -0
  40. package/dist/tableShape.es.js +12 -0
  41. package/dist/tables/stateTransforms.cjs.cjs +200 -0
  42. package/dist/tables/stateTransforms.d.ts +2 -0
  43. package/dist/tables/stateTransforms.es.js +189 -0
  44. package/dist/tables/stateTransforms.json.d.ts +2 -0
  45. package/dist/transform.cjs.cjs +278 -0
  46. package/dist/transform.d.ts +100 -0
  47. package/dist/transform.d.ts.map +1 -0
  48. package/dist/transform.es.js +266 -0
  49. package/dist/translate.cjs.cjs +114 -0
  50. package/dist/translate.d.ts +55 -0
  51. package/dist/translate.d.ts.map +1 -0
  52. package/dist/translate.es.js +112 -0
  53. package/dist/types.cjs.cjs +13 -0
  54. package/dist/types.d.ts +99 -0
  55. package/dist/types.d.ts.map +1 -0
  56. package/dist/types.es.js +10 -0
  57. package/package.json +70 -5
package/README.md ADDED
@@ -0,0 +1,219 @@
1
+ # @jsprismarine/structures
2
+
3
+ The structure template layer: it reads both template formats Mojang ships, translates the Java one
4
+ into Bedrock block states, places a template under a rotation and a mirror, runs the structure
5
+ processors over it, and grows a village or a set of trail ruins out of template pools.
6
+
7
+ Everything it produces is Bedrock-shaped, because that is what the server places.
8
+
9
+ ```ts
10
+ import {
11
+ assembleJigsaw,
12
+ applyProcessors,
13
+ createLegacyRandom,
14
+ createProcessorList,
15
+ isStructureChunk,
16
+ readJavaStructureTemplate,
17
+ readMcStructure,
18
+ transformTemplate,
19
+ translateJavaTemplate
20
+ } from '@jsprismarine/structures';
21
+
22
+ const { template, losses } = translateJavaTemplate(readJavaStructureTemplate(bytes));
23
+ const placed = transformTemplate(template, { rotation: 'clockwise_90', mirror: 'left_right' });
24
+ ```
25
+
26
+ ## The two formats
27
+
28
+ A Minecraft structure template is NBT, and the two editions disagree about almost every part of it.
29
+
30
+ **Java `.nbt`.** Gzip-compressed, big-endian NBT. The root holds `size`, a `palette` of Java block
31
+ states, a `blocks` list of `{pos, state, nbt?}` and an `entities` list of `{pos, blockPos, nbt}`.
32
+ `readJavaStructureTemplate` reads it, compressed or not.
33
+
34
+ Two things vary across the corpus. Java 26.3 renamed the palette entry keys from `Name` and
35
+ `Properties` to `id` and `properties`; the reader prefers the spelling the file's `DataVersion`
36
+ implies and falls back to the other, so a file that disagrees with its own version still reads. The
37
+ hundred oldest files carry `version: 1` and no `DataVersion` at all, and are read by probing the
38
+ keys. Twenty files carry `palettes`, a list of palette variants for the same blocks, which land in
39
+ `paletteVariants`.
40
+
41
+ **Bedrock `.mcstructure`.** Uncompressed, little-endian NBT with Bedrock block states.
42
+ `readMcStructure` reads it. The format differs in four ways that matter: block indices are a flat
43
+ array walking x slowest and z fastest rather than a position per block, `-1` means "change nothing
44
+ here", there are two block storage layers rather than one, and entity positions are world
45
+ coordinates relative to the saved `structure_world_origin` rather than template coordinates. Each
46
+ palette entry carries the game version that wrote its state, kept in `paletteVersions` because the
47
+ oldest files in the corpus were saved by 1.16.
48
+
49
+ Both readers produce positions in template space, with the origin corner at `(0, 0, 0)`.
50
+
51
+ ## The translation and what it costs
52
+
53
+ `translateJavaTemplate` maps a Java palette onto Bedrock states through
54
+ [`@jsprismarine/mapping`](../mapping/README.md) and returns a Bedrock-shaped template. It never
55
+ drops a block quietly: every palette entry that does not map cleanly comes back as a
56
+ `TemplateTranslationLoss` with its kind, the Java state and how many blocks of the template use it.
57
+ Blocks of a lost entry are still placed, as `minecraft:unknown` where the mapping has no state at
58
+ all.
59
+
60
+ Java's `waterlogged` flag has no Bedrock state to live in, so it moves to Bedrock's second block
61
+ storage layer as water. That is the one translation that changes the shape rather than the names,
62
+ and `applyWaterlogging: false` turns it off.
63
+
64
+ Measured over the whole shipped corpus, by the gated test in `src/corpus.test.ts`:
65
+
66
+ | Source | Files | Palette entries | Blocks | Mapped | Lost |
67
+ | --- | --- | --- | --- | --- | --- |
68
+ | Java Edition 26.3 server jar | 1511 | 20791 | 1170664 | 1170664 (100%) | 0 |
69
+ | Bedrock Dedicated Server 1.26.51.1 zip | 1311 | 18043 | 1137782 | 1111645 (97.70%) | 26137 over 1589 entries |
70
+
71
+ The two rows differ because the Bedrock zip's templates were last saved before Java's 1.13
72
+ flattening. Their palettes name 47 identifiers the pinned Java version does not have, among them
73
+ `minecraft:stonebrick` with a `variant`, `minecraft:planks`, `minecraft:log2`, `minecraft:wool` and
74
+ `minecraft:wooden_door`.
75
+
76
+ This package does not carry a 1.12 flattening table, and that is a decision rather than an
77
+ omission. [The plan](../../docs/plans/data-driven-vanilla.md) section 4 sources structures from
78
+ Java's data generator, and the Java corpus translates with nothing lost at all, so the table would
79
+ buy nothing the server uses. The Bedrock zip's templates are a cross-check, and their 47 names are
80
+ reported rather than guessed at. Writing a flattening table is the work to do if those files ever
81
+ become the source.
82
+
83
+ ## Placement transforms
84
+
85
+ `transformTemplate(template, { rotation, mirror })` moves the block positions, the entity positions
86
+ and the direction-valued block states together. The mirror applies before the rotation, as Java
87
+ does. A quarter turn swaps the template's x and z extents, and positions stay inside the
88
+ transformed template rather than spreading around a world pivot.
89
+
90
+ Rotating positions is arithmetic. Rotating states is not, and it is where this would go wrong by
91
+ hand. Bedrock and Java name their direction axes differently: a Java stair's `facing` is a Bedrock
92
+ stair's `weirdo_direction` integer, a Java log's `axis` is a Bedrock log's `pillar_axis`, and a Java
93
+ door facing north is a Bedrock door whose `minecraft:cardinal_direction` is east. Java's own rules
94
+ are also not symmetric. Measured from the pinned server jar, `StairBlock.mirror` swaps the corner
95
+ shape for a z-facing stair under `left_right` and never swaps it under `front_back`, so mirroring
96
+ across one axis is not mirroring across the other followed by a half turn.
97
+
98
+ So the rules are not written here, they are measured. `utils/java-dump/DumpBlockTransforms.java`
99
+ compiles against the pinned server jar and records what `BlockState.rotate` and `BlockState.mirror`
100
+ return for all 35723 Java block states.
101
+ `utils/generate/generate-state-transforms.ts` replays that through the mapping and writes
102
+ `src/tables/stateTransforms.json`, keyed by Bedrock state. Regenerate after a version bump:
103
+
104
+ ```sh
105
+ pnpm --filter @jsprismarine/bedrock-data run fetch:sources
106
+ pnpm exec turbo run build --filter=@jsprismarine/mapping
107
+ pnpm --filter @jsprismarine/structures run generate:transforms
108
+ ```
109
+
110
+ The table covers 508 identifiers that move, out of the 15953 Bedrock states the Java palette
111
+ reaches. Two things it reports rather than hides:
112
+
113
+ - **No rule.** A state no Java block reaches, such as Bedrock's own `minecraft:sulfur_spike`, has no
114
+ entry. It is placed unchanged and listed in `TransformedTemplate.mismatches` with reason
115
+ `no-rule`.
116
+ - **Ambiguous.** 34 transforms over `minecraft:brown_mushroom_block` and
117
+ `minecraft:red_mushroom_block` are ambiguous: Java's six face booleans collapse onto Bedrock's
118
+ 13-value `huge_mushroom_bits`, and the collapsed states do not rotate alike. The table keeps the
119
+ first answer and the placement reports reason `ambiguous`. `AMBIGUOUS_STATE_TRANSFORMS` lists
120
+ them.
121
+
122
+ `verifyStateTransforms()` checks the table against itself: every permutation is a bijection, four
123
+ quarter turns are the identity, the two quarter turns are inverses, and each mirror is its own
124
+ inverse. A test checks it against the mapping's state domains as well, by turning and reflecting
125
+ every one of the 15953 palette states and asserting the result is a state the palette declares.
126
+
127
+ Block entity and entity NBT travels untouched. A jigsaw block entity's `final_state` names a
128
+ direction in text, and transforming that is the caller's job.
129
+
130
+ ## Processors
131
+
132
+ `createProcessorList` reads a Java `worldgen/processor_list` file and `applyProcessors` runs the
133
+ chain over a template. All eleven processor types Java 26.3 registers are implemented, along with
134
+ its ten rule tests, three position tests and four block entity modifiers. The 40 vanilla processor
135
+ lists use four of the eleven: `rule` 39 times, `protected_blocks` 7, `block_rot` 6 and `capped` 4.
136
+
137
+ The draw order matters as much as the rules, because it decides what a seeded placement produces,
138
+ so the branches and the number of draws per branch were read from the pinned jar's own bytecode.
139
+ `block_age`, for instance, builds both its replacement arrays before choosing between them, which
140
+ costs four draws whichever branch wins.
141
+
142
+ Everything a processor needs from outside the template is injected through `ProcessorContext`: the
143
+ random source, the world block at a position, the surface height for the gravity processor, block
144
+ tag membership for `tag_match` and `protected_blocks`, and whether a state fills its cell for the
145
+ lava submerged processor. A chain therefore runs in a test with no world.
146
+
147
+ Two consequences of working in Bedrock states are worth knowing. Block matching compares Bedrock
148
+ identities, so Java states that collapse onto one Bedrock state match together. And Java's
149
+ `withPropertiesOf`, which `block_age` and `blackstone_replace` use to carry a stair's facing onto
150
+ its replacement, copies the state values the two identifiers both declare, read from the same
151
+ pinned palette.
152
+
153
+ ## The jigsaw model
154
+
155
+ A jigsaw block carries a name, a target name, a target pool, a joint type and an orientation. Two
156
+ jigsaws connect when they face each other, the parent's target is the child's name, and either the
157
+ joint is `rollable` or the two share a top facing. Bedrock spells the orientation as a
158
+ `facing_direction` and `rotation` pair where Java spells it as one `orientation` value, and the
159
+ package joins the two through the mapping rather than writing the encoding down.
160
+
161
+ `assembleJigsaw(config, sources)` picks a rotation, draws an element by weight, and walks the
162
+ connections breadth first. For each jigsaw of each placed piece it draws candidates from the
163
+ target pool, then from the pool's fallback, tries the four rotations in a shuffled order, and
164
+ takes the first candidate whose own jigsaw faces back and whose bounding box shares no block with
165
+ a piece already placed. `maxDepth` stops the walk and `maxDistanceFromCenter` bounds it.
166
+
167
+ Three things decide where a piece sits vertically. A `rigid` element hanging off a `rigid` parent
168
+ takes the y its jigsaw lands on. Anything else, which is the 183 `terrain_matching` elements of
169
+ the village street pools, takes the terrain height at its parent's jigsaw instead, read through
170
+ `JigsawSources.terrainHeight`. And `use_expansion_hack`, which 24 of the 28 vanilla jigsaw
171
+ structures set, makes a piece whose own jigsaw points back into its own box as tall as the pool
172
+ that jigsaw targets, so nothing lands in the room it is about to grow into.
173
+
174
+ The start piece settles the same way: `projectStartToHeightmap` adds the structure's start height
175
+ to the terrain at the middle of the piece, and the piece moves so its ground layer, one above its
176
+ floor, lands there. `JigsawAssembly.origin` reports the point Java calls the generation point,
177
+ which is where the structure's biome check is made and what `/locate` names.
178
+
179
+ Every draw goes through the injected `RandomSource`, so a seed and a set of pools always produce
180
+ the same layout. `createLegacyRandom` is Java's own `java.util.Random` generator, reproduced bit for
181
+ bit and tested against values printed by a JDK.
182
+
183
+ The result reports what it could not do: `rejectedForCollision` counts candidate placements a
184
+ bounding box refused, and `unresolvedConnections` counts jigsaws that found no pool, no candidate
185
+ or no room.
186
+
187
+ Two parts of Java's placer are left out. Its free space is a voxel shape and here it is a list of
188
+ piece bounding boxes, which rejects a few placements Java's deflated shape accepts. And
189
+ `placement_priority`, which only the trial chambers use, does not reorder the queue.
190
+
191
+ ## Structure sets and placement
192
+
193
+ `parseStructureSet` reads a `worldgen/structure_set`, and `isStructureChunk` answers whether a
194
+ structure of that set may start in a chunk for a world seed. All three placement types Java
195
+ registers are implemented, along with the four frequency reduction methods. The 21 vanilla sets use
196
+ `random_spread` 20 times and `concentric_rings` once, with `triangular` spread on three and a
197
+ frequency below one on three.
198
+
199
+ The expected positions in the tests come from Java itself: a program built the real
200
+ `RandomSpreadStructurePlacement` with each vanilla set's fields and printed the chunks it chooses
201
+ for one seed.
202
+
203
+ `concentricRingChunks` produces the ring positions strongholds use. Java then moves each one to the
204
+ nearest chunk whose biome is in `preferred_biomes`, which needs a biome source, so these are the
205
+ unsnapped positions and the caller moves them. Exclusion zones are parsed but not applied, for the
206
+ same reason: they depend on another set's placement, so `StructurePlacement.exclusionZone` names the
207
+ set and the radius and the caller resolves it.
208
+
209
+ ## The corpus test
210
+
211
+ `src/corpus.test.ts` reads every template Mojang ships, in both formats, and prints the counts in
212
+ the table above. It needs the pinned sources on disk, so it is gated:
213
+
214
+ ```sh
215
+ pnpm --filter @jsprismarine/bedrock-data run fetch:sources
216
+ JSP_STRUCTURE_CORPUS=1 pnpm --filter @jsprismarine/structures exec vitest run corpus
217
+ ```
218
+
219
+ `JSP_BDS_PATH` and `JSP_JAVA_JAR_PATH` point at local copies instead.
@@ -0,0 +1,23 @@
1
+ "use strict";
2
+ // \0rolldown/runtime.js
3
+ var __create = Object.create;
4
+ var __defProp = Object.defineProperty;
5
+ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
6
+ var __getOwnPropNames = Object.getOwnPropertyNames;
7
+ var __getProtoOf = Object.getPrototypeOf;
8
+ var __hasOwnProp = Object.prototype.hasOwnProperty;
9
+ var __copyProps = (to, from, except, desc) => {
10
+ if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
11
+ key = keys[i];
12
+ if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
13
+ get: ((k) => from[k]).bind(null, key),
14
+ enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
15
+ });
16
+ }
17
+ return to;
18
+ };
19
+ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
20
+ value: mod,
21
+ enumerable: true
22
+ }) : target, mod));
23
+ exports.__toESM = __toESM;
@@ -0,0 +1,144 @@
1
+ "use strict";
2
+ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
3
+ const require_runtime = require("./_virtual/_rolldown/runtime.cjs.cjs");
4
+ const require_types = require("./types.cjs.cjs");
5
+ const require_nbtAccess = require("./nbtAccess.cjs.cjs");
6
+ let _jsprismarine_nbt = require("@jsprismarine/nbt");
7
+ let _jsprismarine_binaryutils = require("@jsprismarine/binaryutils");
8
+ _jsprismarine_binaryutils = require_runtime.__toESM(_jsprismarine_binaryutils, 1);
9
+ // src/bedrockTemplate.ts
10
+ /** The only `format_version` Mojang has published for `.mcstructure` files. */
11
+ var MCSTRUCTURE_FORMAT_VERSION = 1;
12
+ /**
13
+ * The index a `.mcstructure` uses for a block, which walks x slowest and z
14
+ * fastest. Measured against the sulfur spring templates, whose saved block
15
+ * entity coordinates pin the order.
16
+ */
17
+ var mcStructureIndex = (size, x, y, z) => (x * size[1] + y) * size[2] + z;
18
+ /** The template position a `.mcstructure` block index refers to. */
19
+ var mcStructurePosition = (size, index) => [
20
+ Math.floor(index / (size[1] * size[2])),
21
+ Math.floor(index / size[2]) % size[1],
22
+ index % size[2]
23
+ ];
24
+ var readLayer = (structure, layer) => {
25
+ const entry = require_nbtAccess.listAt(structure, "block_indices")[layer];
26
+ if (entry === void 0) return void 0;
27
+ if (!(entry instanceof Set)) throw new require_types.StructureFormatError("mcstructure: block_indices layer is not a list");
28
+ const indices = require_nbtAccess.numbersOf([...entry]);
29
+ if (indices.length !== entry.size) throw new require_types.StructureFormatError("mcstructure: block_indices holds a non-numeric entry");
30
+ return indices;
31
+ };
32
+ var readPalette = (structure) => {
33
+ const palettes = require_nbtAccess.compoundAt(structure, "palette");
34
+ const chosen = palettes === void 0 ? void 0 : require_nbtAccess.compoundAt(palettes, "default");
35
+ if (chosen === void 0) throw new require_types.StructureFormatError("mcstructure: no default palette");
36
+ const palette = [];
37
+ const versions = [];
38
+ for (const entry of require_nbtAccess.compoundListAt(chosen, "block_palette")) {
39
+ const name = require_nbtAccess.stringAt(entry, "name");
40
+ if (name === void 0) throw new require_types.StructureFormatError("mcstructure: palette entry has no name");
41
+ palette.push({
42
+ name,
43
+ states: require_nbtAccess.stateRecord(require_nbtAccess.compoundAt(entry, "states"))
44
+ });
45
+ versions.push(require_nbtAccess.numberAt(entry, "version") ?? 0);
46
+ }
47
+ return {
48
+ palette,
49
+ versions
50
+ };
51
+ };
52
+ /** The per-index block entity and tick queue records, keyed by the index's decimal string. */
53
+ var readPositionData = (structure) => {
54
+ const data = /* @__PURE__ */ new Map();
55
+ const palettes = require_nbtAccess.compoundAt(structure, "palette");
56
+ const chosen = palettes === void 0 ? void 0 : require_nbtAccess.compoundAt(palettes, "default");
57
+ const positions = chosen === void 0 ? void 0 : require_nbtAccess.compoundAt(chosen, "block_position_data");
58
+ if (positions === void 0) return data;
59
+ for (const [key, value] of positions.entries()) {
60
+ const index = Number.parseInt(key, 10);
61
+ if (!Number.isInteger(index) || !(value instanceof _jsprismarine_nbt.NBTTagCompound)) continue;
62
+ const tickDelays = require_nbtAccess.compoundListAt(value, "tick_queue_data").map((tick) => require_nbtAccess.numberAt(tick, "tick_delay") ?? 0);
63
+ data.set(index, {
64
+ ...require_nbtAccess.compoundAt(value, "block_entity_data") === void 0 ? {} : { nbt: require_nbtAccess.compoundAt(value, "block_entity_data") },
65
+ ...tickDelays.length === 0 ? {} : { tickDelays }
66
+ });
67
+ }
68
+ return data;
69
+ };
70
+ var readEntities = (structure, origin) => require_nbtAccess.compoundListAt(structure, "entities").map((entity) => {
71
+ const [x = 0, y = 0, z = 0] = require_nbtAccess.numberListAt(entity, "Pos");
72
+ return {
73
+ pos: [
74
+ x - origin[0],
75
+ y - origin[1],
76
+ z - origin[2]
77
+ ],
78
+ nbt: entity
79
+ };
80
+ });
81
+ /**
82
+ * Reads a Bedrock `.mcstructure` template: uncompressed little-endian NBT
83
+ * with Bedrock block states, two block storage layers and world-coordinate
84
+ * entity positions. Fifteen of these ship in the Bedrock Dedicated Server
85
+ * zip, where everything else is the Java format.
86
+ *
87
+ * Positions where both layers hold no block are left out of
88
+ * {@link BedrockStructureTemplate.blocks}, since the format uses them for
89
+ * "change nothing here".
90
+ *
91
+ * @throws {StructureFormatError} When the bytes are not a `.mcstructure`.
92
+ */
93
+ var readMcStructure = (bytes) => {
94
+ const buffer = Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
95
+ let root;
96
+ try {
97
+ root = _jsprismarine_nbt.NBTTagCompound.readFromStream(new _jsprismarine_binaryutils.default(buffer), _jsprismarine_nbt.ByteOrder.LITTLE_ENDIAN);
98
+ } catch (error) {
99
+ throw new require_types.StructureFormatError(`mcstructure: ${error instanceof Error ? error.message : String(error)}`);
100
+ }
101
+ const formatVersion = require_nbtAccess.numberAt(root, "format_version");
102
+ if (formatVersion !== void 0 && formatVersion !== 1) throw new require_types.StructureFormatError(`mcstructure: unsupported format_version ${formatVersion}`);
103
+ const size = require_nbtAccess.tripleAt(root, "size", "mcstructure");
104
+ const structure = require_nbtAccess.compoundAt(root, "structure");
105
+ if (structure === void 0) throw new require_types.StructureFormatError("mcstructure: no structure compound");
106
+ const worldOrigin = require_nbtAccess.numberListAt(root, "structure_world_origin").length === 3 ? require_nbtAccess.tripleAt(root, "structure_world_origin", "mcstructure") : [
107
+ 0,
108
+ 0,
109
+ 0
110
+ ];
111
+ const primary = readLayer(structure, 0);
112
+ if (primary === void 0) throw new require_types.StructureFormatError("mcstructure: no block_indices");
113
+ const secondary = readLayer(structure, 1);
114
+ const expected = size[0] * size[1] * size[2];
115
+ if (primary.length !== expected) throw new require_types.StructureFormatError(`mcstructure: block_indices holds ${primary.length} entries for a ${size.join("x")} template`);
116
+ const { palette, versions } = readPalette(structure);
117
+ const positionData = readPositionData(structure);
118
+ const blocks = [];
119
+ for (let index = 0; index < primary.length; index++) {
120
+ const state = primary[index] ?? -1;
121
+ const extraState = secondary?.[index] ?? -1;
122
+ if (state === -1 && extraState === -1) continue;
123
+ blocks.push({
124
+ pos: mcStructurePosition(size, index),
125
+ state,
126
+ extraState,
127
+ ...positionData.get(index) ?? {}
128
+ });
129
+ }
130
+ return {
131
+ size,
132
+ palette,
133
+ paletteVersions: versions,
134
+ blocks,
135
+ entities: readEntities(structure, worldOrigin),
136
+ worldOrigin
137
+ };
138
+ };
139
+ exports.MCSTRUCTURE_FORMAT_VERSION = MCSTRUCTURE_FORMAT_VERSION;
140
+ exports.mcStructureIndex = mcStructureIndex;
141
+ exports.mcStructurePosition = mcStructurePosition;
142
+ exports.readMcStructure = readMcStructure;
143
+
144
+ //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"bedrockTemplate.cjs.cjs","names":["listAt","StructureFormatError","numbersOf","compoundAt","compoundListAt","stringAt","stateRecord","numberAt","NBTTagCompound","numberListAt","BinaryStream","ByteOrder","tripleAt"],"sources":["../src/bedrockTemplate.ts"],"sourcesContent":["import BinaryStream from '@jsprismarine/binaryutils';\nimport { ByteOrder, NBTTagCompound } from '@jsprismarine/nbt';\n\nimport {\n    compoundAt,\n    compoundListAt,\n    listAt,\n    numberAt,\n    numberListAt,\n    numbersOf,\n    stateRecord,\n    stringAt,\n    tripleAt\n} from './nbtAccess';\nimport type {\n    BedrockBlockState,\n    BedrockStructureTemplate,\n    BedrockTemplateBlock,\n    TemplateEntity,\n    TemplatePosition\n} from './types';\nimport { NO_BLOCK, StructureFormatError } from './types';\n\n/** The only `format_version` Mojang has published for `.mcstructure` files. */\nexport const MCSTRUCTURE_FORMAT_VERSION = 1;\n\n/**\n * The index a `.mcstructure` uses for a block, which walks x slowest and z\n * fastest. Measured against the sulfur spring templates, whose saved block\n * entity coordinates pin the order.\n */\nexport const mcStructureIndex = (size: TemplatePosition, x: number, y: number, z: number): number =>\n    (x * size[1] + y) * size[2] + z;\n\n/** The template position a `.mcstructure` block index refers to. */\nexport const mcStructurePosition = (size: TemplatePosition, index: number): TemplatePosition => [\n    Math.floor(index / (size[1] * size[2])),\n    Math.floor(index / size[2]) % size[1],\n    index % size[2]\n];\n\nconst readLayer = (structure: NBTTagCompound, layer: number): number[] | undefined => {\n    const entry = listAt(structure, 'block_indices')[layer];\n    if (entry === undefined) return undefined;\n    if (!(entry instanceof Set)) throw new StructureFormatError('mcstructure: block_indices layer is not a list');\n\n    const indices = numbersOf([...entry]);\n    if (indices.length !== entry.size) {\n        throw new StructureFormatError('mcstructure: block_indices holds a non-numeric entry');\n    }\n    return indices;\n};\n\nconst readPalette = (structure: NBTTagCompound): { palette: BedrockBlockState[]; versions: number[] } => {\n    const palettes = compoundAt(structure, 'palette');\n    const chosen = palettes === undefined ? undefined : compoundAt(palettes, 'default');\n    if (chosen === undefined) throw new StructureFormatError('mcstructure: no default palette');\n\n    const palette: BedrockBlockState[] = [];\n    const versions: number[] = [];\n    for (const entry of compoundListAt(chosen, 'block_palette')) {\n        const name = stringAt(entry, 'name');\n        if (name === undefined) throw new StructureFormatError('mcstructure: palette entry has no name');\n        palette.push({ name, states: stateRecord(compoundAt(entry, 'states')) });\n        versions.push(numberAt(entry, 'version') ?? 0);\n    }\n    return { palette, versions };\n};\n\n/** The per-index block entity and tick queue records, keyed by the index's decimal string. */\nconst readPositionData = (structure: NBTTagCompound): Map<number, { nbt?: NBTTagCompound; tickDelays?: number[] }> => {\n    const data = new Map<number, { nbt?: NBTTagCompound; tickDelays?: number[] }>();\n    const palettes = compoundAt(structure, 'palette');\n    const chosen = palettes === undefined ? undefined : compoundAt(palettes, 'default');\n    const positions = chosen === undefined ? undefined : compoundAt(chosen, 'block_position_data');\n    if (positions === undefined) return data;\n\n    for (const [key, value] of positions.entries()) {\n        const index = Number.parseInt(key, 10);\n        if (!Number.isInteger(index) || !(value instanceof NBTTagCompound)) continue;\n        const tickDelays = compoundListAt(value, 'tick_queue_data').map((tick) => numberAt(tick, 'tick_delay') ?? 0);\n        data.set(index, {\n            ...(compoundAt(value, 'block_entity_data') === undefined\n                ? {}\n                : { nbt: compoundAt(value, 'block_entity_data') }),\n            ...(tickDelays.length === 0 ? {} : { tickDelays })\n        });\n    }\n    return data;\n};\n\nconst readEntities = (structure: NBTTagCompound, origin: TemplatePosition): TemplateEntity[] =>\n    compoundListAt(structure, 'entities').map((entity) => {\n        const [x = 0, y = 0, z = 0] = numberListAt(entity, 'Pos');\n        // `.mcstructure` saves entity positions in world coordinates; the\n        // template-relative position is the offset from the saved origin.\n        return { pos: [x - origin[0], y - origin[1], z - origin[2]] as const, nbt: entity };\n    });\n\n/**\n * Reads a Bedrock `.mcstructure` template: uncompressed little-endian NBT\n * with Bedrock block states, two block storage layers and world-coordinate\n * entity positions. Fifteen of these ship in the Bedrock Dedicated Server\n * zip, where everything else is the Java format.\n *\n * Positions where both layers hold no block are left out of\n * {@link BedrockStructureTemplate.blocks}, since the format uses them for\n * \"change nothing here\".\n *\n * @throws {StructureFormatError} When the bytes are not a `.mcstructure`.\n */\nexport const readMcStructure = (bytes: Uint8Array): BedrockStructureTemplate => {\n    const buffer = Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n\n    let root: NBTTagCompound;\n    try {\n        root = NBTTagCompound.readFromStream(new BinaryStream(buffer), ByteOrder.LITTLE_ENDIAN);\n    } catch (error) {\n        throw new StructureFormatError(`mcstructure: ${error instanceof Error ? error.message : String(error)}`);\n    }\n\n    const formatVersion = numberAt(root, 'format_version');\n    if (formatVersion !== undefined && formatVersion !== MCSTRUCTURE_FORMAT_VERSION) {\n        throw new StructureFormatError(`mcstructure: unsupported format_version ${formatVersion}`);\n    }\n\n    const size = tripleAt(root, 'size', 'mcstructure');\n    const structure = compoundAt(root, 'structure');\n    if (structure === undefined) throw new StructureFormatError('mcstructure: no structure compound');\n\n    const worldOrigin: TemplatePosition =\n        numberListAt(root, 'structure_world_origin').length === 3\n            ? tripleAt(root, 'structure_world_origin', 'mcstructure')\n            : [0, 0, 0];\n\n    const primary = readLayer(structure, 0);\n    if (primary === undefined) throw new StructureFormatError('mcstructure: no block_indices');\n    const secondary = readLayer(structure, 1);\n\n    const expected = size[0] * size[1] * size[2];\n    if (primary.length !== expected) {\n        throw new StructureFormatError(\n            `mcstructure: block_indices holds ${primary.length} entries for a ${size.join('x')} template`\n        );\n    }\n\n    const { palette, versions } = readPalette(structure);\n    const positionData = readPositionData(structure);\n\n    const blocks: BedrockTemplateBlock[] = [];\n    for (let index = 0; index < primary.length; index++) {\n        const state = primary[index] ?? NO_BLOCK;\n        const extraState = secondary?.[index] ?? NO_BLOCK;\n        if (state === NO_BLOCK && extraState === NO_BLOCK) continue;\n        blocks.push({\n            pos: mcStructurePosition(size, index),\n            state,\n            extraState,\n            ...(positionData.get(index) ?? {})\n        });\n    }\n\n    return {\n        size,\n        palette,\n        paletteVersions: versions,\n        blocks,\n        entities: readEntities(structure, worldOrigin),\n        worldOrigin\n    };\n};\n"],"mappings":"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"}
@@ -0,0 +1,25 @@
1
+ import type { BedrockStructureTemplate, TemplatePosition } from './types';
2
+ /** The only `format_version` Mojang has published for `.mcstructure` files. */
3
+ export declare const MCSTRUCTURE_FORMAT_VERSION = 1;
4
+ /**
5
+ * The index a `.mcstructure` uses for a block, which walks x slowest and z
6
+ * fastest. Measured against the sulfur spring templates, whose saved block
7
+ * entity coordinates pin the order.
8
+ */
9
+ export declare const mcStructureIndex: (size: TemplatePosition, x: number, y: number, z: number) => number;
10
+ /** The template position a `.mcstructure` block index refers to. */
11
+ export declare const mcStructurePosition: (size: TemplatePosition, index: number) => TemplatePosition;
12
+ /**
13
+ * Reads a Bedrock `.mcstructure` template: uncompressed little-endian NBT
14
+ * with Bedrock block states, two block storage layers and world-coordinate
15
+ * entity positions. Fifteen of these ship in the Bedrock Dedicated Server
16
+ * zip, where everything else is the Java format.
17
+ *
18
+ * Positions where both layers hold no block are left out of
19
+ * {@link BedrockStructureTemplate.blocks}, since the format uses them for
20
+ * "change nothing here".
21
+ *
22
+ * @throws {StructureFormatError} When the bytes are not a `.mcstructure`.
23
+ */
24
+ export declare const readMcStructure: (bytes: Uint8Array) => BedrockStructureTemplate;
25
+ //# sourceMappingURL=bedrockTemplate.d.ts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"bedrockTemplate.d.ts","sourceRoot":"","sources":["../src/bedrockTemplate.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAER,wBAAwB,EAGxB,gBAAgB,EACnB,MAAM,SAAS,CAAC;AAGjB,+EAA+E;AAC/E,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAE5C;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,SAAU,gBAAgB,KAAK,MAAM,KAAK,MAAM,KAAK,MAAM,KAAG,MACxD,CAAC;AAEpC,oEAAoE;AACpE,eAAO,MAAM,mBAAmB,SAAU,gBAAgB,SAAS,MAAM,KAAG,gBAI3E,CAAC;AA4DF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,UAAW,UAAU,KAAG,wBA2DnD,CAAC"}
@@ -0,0 +1,137 @@
1
+ import { StructureFormatError } from "./types.es.js";
2
+ import { compoundAt, compoundListAt, listAt, numberAt, numberListAt, numbersOf, stateRecord, stringAt, tripleAt } from "./nbtAccess.es.js";
3
+ import { ByteOrder, NBTTagCompound } from "@jsprismarine/nbt";
4
+ import BinaryStream from "@jsprismarine/binaryutils";
5
+ // src/bedrockTemplate.ts
6
+ /** The only `format_version` Mojang has published for `.mcstructure` files. */
7
+ var MCSTRUCTURE_FORMAT_VERSION = 1;
8
+ /**
9
+ * The index a `.mcstructure` uses for a block, which walks x slowest and z
10
+ * fastest. Measured against the sulfur spring templates, whose saved block
11
+ * entity coordinates pin the order.
12
+ */
13
+ var mcStructureIndex = (size, x, y, z) => (x * size[1] + y) * size[2] + z;
14
+ /** The template position a `.mcstructure` block index refers to. */
15
+ var mcStructurePosition = (size, index) => [
16
+ Math.floor(index / (size[1] * size[2])),
17
+ Math.floor(index / size[2]) % size[1],
18
+ index % size[2]
19
+ ];
20
+ var readLayer = (structure, layer) => {
21
+ const entry = listAt(structure, "block_indices")[layer];
22
+ if (entry === void 0) return void 0;
23
+ if (!(entry instanceof Set)) throw new StructureFormatError("mcstructure: block_indices layer is not a list");
24
+ const indices = numbersOf([...entry]);
25
+ if (indices.length !== entry.size) throw new StructureFormatError("mcstructure: block_indices holds a non-numeric entry");
26
+ return indices;
27
+ };
28
+ var readPalette = (structure) => {
29
+ const palettes = compoundAt(structure, "palette");
30
+ const chosen = palettes === void 0 ? void 0 : compoundAt(palettes, "default");
31
+ if (chosen === void 0) throw new StructureFormatError("mcstructure: no default palette");
32
+ const palette = [];
33
+ const versions = [];
34
+ for (const entry of compoundListAt(chosen, "block_palette")) {
35
+ const name = stringAt(entry, "name");
36
+ if (name === void 0) throw new StructureFormatError("mcstructure: palette entry has no name");
37
+ palette.push({
38
+ name,
39
+ states: stateRecord(compoundAt(entry, "states"))
40
+ });
41
+ versions.push(numberAt(entry, "version") ?? 0);
42
+ }
43
+ return {
44
+ palette,
45
+ versions
46
+ };
47
+ };
48
+ /** The per-index block entity and tick queue records, keyed by the index's decimal string. */
49
+ var readPositionData = (structure) => {
50
+ const data = /* @__PURE__ */ new Map();
51
+ const palettes = compoundAt(structure, "palette");
52
+ const chosen = palettes === void 0 ? void 0 : compoundAt(palettes, "default");
53
+ const positions = chosen === void 0 ? void 0 : compoundAt(chosen, "block_position_data");
54
+ if (positions === void 0) return data;
55
+ for (const [key, value] of positions.entries()) {
56
+ const index = Number.parseInt(key, 10);
57
+ if (!Number.isInteger(index) || !(value instanceof NBTTagCompound)) continue;
58
+ const tickDelays = compoundListAt(value, "tick_queue_data").map((tick) => numberAt(tick, "tick_delay") ?? 0);
59
+ data.set(index, {
60
+ ...compoundAt(value, "block_entity_data") === void 0 ? {} : { nbt: compoundAt(value, "block_entity_data") },
61
+ ...tickDelays.length === 0 ? {} : { tickDelays }
62
+ });
63
+ }
64
+ return data;
65
+ };
66
+ var readEntities = (structure, origin) => compoundListAt(structure, "entities").map((entity) => {
67
+ const [x = 0, y = 0, z = 0] = numberListAt(entity, "Pos");
68
+ return {
69
+ pos: [
70
+ x - origin[0],
71
+ y - origin[1],
72
+ z - origin[2]
73
+ ],
74
+ nbt: entity
75
+ };
76
+ });
77
+ /**
78
+ * Reads a Bedrock `.mcstructure` template: uncompressed little-endian NBT
79
+ * with Bedrock block states, two block storage layers and world-coordinate
80
+ * entity positions. Fifteen of these ship in the Bedrock Dedicated Server
81
+ * zip, where everything else is the Java format.
82
+ *
83
+ * Positions where both layers hold no block are left out of
84
+ * {@link BedrockStructureTemplate.blocks}, since the format uses them for
85
+ * "change nothing here".
86
+ *
87
+ * @throws {StructureFormatError} When the bytes are not a `.mcstructure`.
88
+ */
89
+ var readMcStructure = (bytes) => {
90
+ const buffer = Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
91
+ let root;
92
+ try {
93
+ root = NBTTagCompound.readFromStream(new BinaryStream(buffer), ByteOrder.LITTLE_ENDIAN);
94
+ } catch (error) {
95
+ throw new StructureFormatError(`mcstructure: ${error instanceof Error ? error.message : String(error)}`);
96
+ }
97
+ const formatVersion = numberAt(root, "format_version");
98
+ if (formatVersion !== void 0 && formatVersion !== 1) throw new StructureFormatError(`mcstructure: unsupported format_version ${formatVersion}`);
99
+ const size = tripleAt(root, "size", "mcstructure");
100
+ const structure = compoundAt(root, "structure");
101
+ if (structure === void 0) throw new StructureFormatError("mcstructure: no structure compound");
102
+ const worldOrigin = numberListAt(root, "structure_world_origin").length === 3 ? tripleAt(root, "structure_world_origin", "mcstructure") : [
103
+ 0,
104
+ 0,
105
+ 0
106
+ ];
107
+ const primary = readLayer(structure, 0);
108
+ if (primary === void 0) throw new StructureFormatError("mcstructure: no block_indices");
109
+ const secondary = readLayer(structure, 1);
110
+ const expected = size[0] * size[1] * size[2];
111
+ if (primary.length !== expected) throw new StructureFormatError(`mcstructure: block_indices holds ${primary.length} entries for a ${size.join("x")} template`);
112
+ const { palette, versions } = readPalette(structure);
113
+ const positionData = readPositionData(structure);
114
+ const blocks = [];
115
+ for (let index = 0; index < primary.length; index++) {
116
+ const state = primary[index] ?? -1;
117
+ const extraState = secondary?.[index] ?? -1;
118
+ if (state === -1 && extraState === -1) continue;
119
+ blocks.push({
120
+ pos: mcStructurePosition(size, index),
121
+ state,
122
+ extraState,
123
+ ...positionData.get(index) ?? {}
124
+ });
125
+ }
126
+ return {
127
+ size,
128
+ palette,
129
+ paletteVersions: versions,
130
+ blocks,
131
+ entities: readEntities(structure, worldOrigin),
132
+ worldOrigin
133
+ };
134
+ };
135
+ export { MCSTRUCTURE_FORMAT_VERSION, mcStructureIndex, mcStructurePosition, readMcStructure };
136
+
137
+ //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"bedrockTemplate.es.js","names":[],"sources":["../src/bedrockTemplate.ts"],"sourcesContent":["import BinaryStream from '@jsprismarine/binaryutils';\nimport { ByteOrder, NBTTagCompound } from '@jsprismarine/nbt';\n\nimport {\n    compoundAt,\n    compoundListAt,\n    listAt,\n    numberAt,\n    numberListAt,\n    numbersOf,\n    stateRecord,\n    stringAt,\n    tripleAt\n} from './nbtAccess';\nimport type {\n    BedrockBlockState,\n    BedrockStructureTemplate,\n    BedrockTemplateBlock,\n    TemplateEntity,\n    TemplatePosition\n} from './types';\nimport { NO_BLOCK, StructureFormatError } from './types';\n\n/** The only `format_version` Mojang has published for `.mcstructure` files. */\nexport const MCSTRUCTURE_FORMAT_VERSION = 1;\n\n/**\n * The index a `.mcstructure` uses for a block, which walks x slowest and z\n * fastest. Measured against the sulfur spring templates, whose saved block\n * entity coordinates pin the order.\n */\nexport const mcStructureIndex = (size: TemplatePosition, x: number, y: number, z: number): number =>\n    (x * size[1] + y) * size[2] + z;\n\n/** The template position a `.mcstructure` block index refers to. */\nexport const mcStructurePosition = (size: TemplatePosition, index: number): TemplatePosition => [\n    Math.floor(index / (size[1] * size[2])),\n    Math.floor(index / size[2]) % size[1],\n    index % size[2]\n];\n\nconst readLayer = (structure: NBTTagCompound, layer: number): number[] | undefined => {\n    const entry = listAt(structure, 'block_indices')[layer];\n    if (entry === undefined) return undefined;\n    if (!(entry instanceof Set)) throw new StructureFormatError('mcstructure: block_indices layer is not a list');\n\n    const indices = numbersOf([...entry]);\n    if (indices.length !== entry.size) {\n        throw new StructureFormatError('mcstructure: block_indices holds a non-numeric entry');\n    }\n    return indices;\n};\n\nconst readPalette = (structure: NBTTagCompound): { palette: BedrockBlockState[]; versions: number[] } => {\n    const palettes = compoundAt(structure, 'palette');\n    const chosen = palettes === undefined ? undefined : compoundAt(palettes, 'default');\n    if (chosen === undefined) throw new StructureFormatError('mcstructure: no default palette');\n\n    const palette: BedrockBlockState[] = [];\n    const versions: number[] = [];\n    for (const entry of compoundListAt(chosen, 'block_palette')) {\n        const name = stringAt(entry, 'name');\n        if (name === undefined) throw new StructureFormatError('mcstructure: palette entry has no name');\n        palette.push({ name, states: stateRecord(compoundAt(entry, 'states')) });\n        versions.push(numberAt(entry, 'version') ?? 0);\n    }\n    return { palette, versions };\n};\n\n/** The per-index block entity and tick queue records, keyed by the index's decimal string. */\nconst readPositionData = (structure: NBTTagCompound): Map<number, { nbt?: NBTTagCompound; tickDelays?: number[] }> => {\n    const data = new Map<number, { nbt?: NBTTagCompound; tickDelays?: number[] }>();\n    const palettes = compoundAt(structure, 'palette');\n    const chosen = palettes === undefined ? undefined : compoundAt(palettes, 'default');\n    const positions = chosen === undefined ? undefined : compoundAt(chosen, 'block_position_data');\n    if (positions === undefined) return data;\n\n    for (const [key, value] of positions.entries()) {\n        const index = Number.parseInt(key, 10);\n        if (!Number.isInteger(index) || !(value instanceof NBTTagCompound)) continue;\n        const tickDelays = compoundListAt(value, 'tick_queue_data').map((tick) => numberAt(tick, 'tick_delay') ?? 0);\n        data.set(index, {\n            ...(compoundAt(value, 'block_entity_data') === undefined\n                ? {}\n                : { nbt: compoundAt(value, 'block_entity_data') }),\n            ...(tickDelays.length === 0 ? {} : { tickDelays })\n        });\n    }\n    return data;\n};\n\nconst readEntities = (structure: NBTTagCompound, origin: TemplatePosition): TemplateEntity[] =>\n    compoundListAt(structure, 'entities').map((entity) => {\n        const [x = 0, y = 0, z = 0] = numberListAt(entity, 'Pos');\n        // `.mcstructure` saves entity positions in world coordinates; the\n        // template-relative position is the offset from the saved origin.\n        return { pos: [x - origin[0], y - origin[1], z - origin[2]] as const, nbt: entity };\n    });\n\n/**\n * Reads a Bedrock `.mcstructure` template: uncompressed little-endian NBT\n * with Bedrock block states, two block storage layers and world-coordinate\n * entity positions. Fifteen of these ship in the Bedrock Dedicated Server\n * zip, where everything else is the Java format.\n *\n * Positions where both layers hold no block are left out of\n * {@link BedrockStructureTemplate.blocks}, since the format uses them for\n * \"change nothing here\".\n *\n * @throws {StructureFormatError} When the bytes are not a `.mcstructure`.\n */\nexport const readMcStructure = (bytes: Uint8Array): BedrockStructureTemplate => {\n    const buffer = Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n\n    let root: NBTTagCompound;\n    try {\n        root = NBTTagCompound.readFromStream(new BinaryStream(buffer), ByteOrder.LITTLE_ENDIAN);\n    } catch (error) {\n        throw new StructureFormatError(`mcstructure: ${error instanceof Error ? error.message : String(error)}`);\n    }\n\n    const formatVersion = numberAt(root, 'format_version');\n    if (formatVersion !== undefined && formatVersion !== MCSTRUCTURE_FORMAT_VERSION) {\n        throw new StructureFormatError(`mcstructure: unsupported format_version ${formatVersion}`);\n    }\n\n    const size = tripleAt(root, 'size', 'mcstructure');\n    const structure = compoundAt(root, 'structure');\n    if (structure === undefined) throw new StructureFormatError('mcstructure: no structure compound');\n\n    const worldOrigin: TemplatePosition =\n        numberListAt(root, 'structure_world_origin').length === 3\n            ? tripleAt(root, 'structure_world_origin', 'mcstructure')\n            : [0, 0, 0];\n\n    const primary = readLayer(structure, 0);\n    if (primary === undefined) throw new StructureFormatError('mcstructure: no block_indices');\n    const secondary = readLayer(structure, 1);\n\n    const expected = size[0] * size[1] * size[2];\n    if (primary.length !== expected) {\n        throw new StructureFormatError(\n            `mcstructure: block_indices holds ${primary.length} entries for a ${size.join('x')} template`\n        );\n    }\n\n    const { palette, versions } = readPalette(structure);\n    const positionData = readPositionData(structure);\n\n    const blocks: BedrockTemplateBlock[] = [];\n    for (let index = 0; index < primary.length; index++) {\n        const state = primary[index] ?? NO_BLOCK;\n        const extraState = secondary?.[index] ?? NO_BLOCK;\n        if (state === NO_BLOCK && extraState === NO_BLOCK) continue;\n        blocks.push({\n            pos: mcStructurePosition(size, index),\n            state,\n            extraState,\n            ...(positionData.get(index) ?? {})\n        });\n    }\n\n    return {\n        size,\n        palette,\n        paletteVersions: versions,\n        blocks,\n        entities: readEntities(structure, worldOrigin),\n        worldOrigin\n    };\n};\n"],"mappings":"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"}