sandstone 1.1.1 → 1.1.2

package/src/core/resources/resourcepack/itemDefinition.ts

@@ -1,4 +1,4 @@
-import { RESOURCE_PATHS } from 'sandstone/arguments'
+import { type MCDocToJSON, RESOURCE_PATHS } from 'sandstone/arguments'
 import type {
   ItemDefinition,
   ItemModel,
@@ -9,8 +9,6 @@ import type {
   SpecialModel,
 } from 'sandstone/arguments/generated/assets/item_definition'
 import type { ModelRef } from 'sandstone/arguments/generated/assets/model'
-import type { NBTFloat } from 'sandstone'
-import { NBT } from 'sandstone/variables/nbt'
 import { ContainerNode } from '../../nodes'
 import type { SandstoneCore } from '../../sandstoneCore'
 import type { ResourceClassArguments, ResourceNode } from '../resource'
@@ -19,8 +17,14 @@ import { ModelClass } from './model'
 import { ItemPredicateClass } from 'sandstone/variables/ItemPredicate'
 import type { SandstonePack } from 'sandstone/pack'
 
+type JSONItemDefinition = MCDocToJSON<ItemDefinition>
+type JSONItemModel = MCDocToJSON<ItemModel>
+type JSONRangeDispatch = MCDocToJSON<RangeDispatch>
+type JSONSelect = MCDocToJSON<Select>
+type JSONSpecialModel = MCDocToJSON<SpecialModel>
+
 // Helper to normalize model input (string/ModelClass -> { type: 'model', model: ModelRef })
-function normalizeModel(input: ItemModel | ModelRef): ItemModel {
+function normalizeModel(input: JSONItemModel | ModelRef): JSONItemModel {
   if (typeof input === 'string' || input instanceof ModelClass) {
     return { type: 'model', model: input as ModelRef }
   }
@@ -33,9 +37,9 @@ function normalizeModel(input: ItemModel | ModelRef): ItemModel {
  * and adds model-specific methods for building ItemModel JSON.
  */
 export class ItemModelBuilder extends ItemPredicateClass {
-  private onTrueModel?: ItemModel
-  private onFalseModel?: ItemModel
-  private explicitModel?: ItemModel
+  private onTrueModel?: JSONItemModel
+  private onFalseModel?: JSONItemModel
+  private explicitModel?: JSONItemModel
 
   // ItemModelDefinition-level options
   private _handAnimationOnSwap?: boolean
@@ -50,7 +54,7 @@ export class ItemModelBuilder extends ItemPredicateClass {
    * Specify the model to use when all conditions match.
    * @param model The ItemModel or model reference string
    */
-  onTrue(model: ItemModel | ModelRef): this {
+  onTrue(model: JSONItemModel | ModelRef): this {
     this.onTrueModel = normalizeModel(model)
     return this
   }
@@ -59,7 +63,7 @@ export class ItemModelBuilder extends ItemPredicateClass {
    * Specify the model to use when any condition fails.
    * @param model The ItemModel or model reference string
    */
-  onFalse(model: ItemModel | ModelRef): this {
+  onFalse(model: JSONItemModel | ModelRef): this {
     this.onFalseModel = normalizeModel(model)
     return this
   }
@@ -68,7 +72,7 @@ export class ItemModelBuilder extends ItemPredicateClass {
    * Create a composite model that renders multiple models layered together.
    * @param models The models to compose
    */
-  composite(...models: Array<ItemModel | ModelRef>): this {
+  composite(...models: Array<JSONItemModel | ModelRef>): this {
     this.explicitModel = {
       type: 'composite',
       models: models.map(normalizeModel),
@@ -83,13 +87,13 @@ export class ItemModelBuilder extends ItemPredicateClass {
    */
   select<P extends SelectPropertyType>(
     property: P,
-    config: Omit<Extract<Select, { property: P | `minecraft:${P}` }>, 'type' | 'property'>,
+    config: Omit<Extract<JSONSelect, { property: P | `minecraft:${P}` }>, 'type' | 'property'>,
   ): this {
     this.explicitModel = {
       type: 'select',
       property,
       ...config,
-    } as ItemModel
+    } as JSONItemModel
     return this
   }
 
@@ -100,13 +104,13 @@ export class ItemModelBuilder extends ItemPredicateClass {
    */
   rangeDispatch<P extends NumericPropertyType>(
     property: P,
-    config: Omit<Extract<RangeDispatch, { property: P | `minecraft:${P}` }>, 'type' | 'property'>,
+    config: Omit<Extract<JSONRangeDispatch, { property: P | `minecraft:${P}` }>, 'type' | 'property'>,
   ): this {
     this.explicitModel = {
       type: 'range_dispatch',
       property,
       ...config,
-    } as ItemModel
+    } as JSONItemModel
     return this
   }
 
@@ -115,7 +119,7 @@ export class ItemModelBuilder extends ItemPredicateClass {
    * @param model The special model configuration
    * @param base The base model reference providing transformations
    */
-  special(model: SpecialModel, base: ModelRef): this {
+  special(model: JSONSpecialModel, base: ModelRef): this {
     this.explicitModel = {
       type: 'special',
       model,
@@ -162,7 +166,7 @@ export class ItemModelBuilder extends ItemPredicateClass {
   /**
    * Build the ItemModel JSON from the builder configuration.
    */
-  toItemModel(): ItemModel {
+  toItemModel(): JSONItemModel {
     if (this.explicitModel) {
       return this.explicitModel
     }
@@ -172,16 +176,16 @@ export class ItemModelBuilder extends ItemPredicateClass {
   /**
    * Build the complete ItemModelDefinition JSON including model and options.
    */
-  toItemModelDefinition(): ItemDefinition {
+  toItemModelDefinition(): JSONItemDefinition {
     return {
       model: this.toItemModel(),
       ...(this._handAnimationOnSwap !== undefined && { hand_animation_on_swap: this._handAnimationOnSwap }),
       ...(this._oversizedInGui !== undefined && { oversized_in_gui: this._oversizedInGui }),
-      ...(this._swapAnimationScale !== undefined && { swap_animation_scale: NBT.float(this._swapAnimationScale) }),
+      ...(this._swapAnimationScale !== undefined && { swap_animation_scale: this._swapAnimationScale }),
     }
   }
 
-  private buildFromPredicates(): ItemModel {
+  private buildFromPredicates(): JSONItemModel {
     // Check for OR groups which are not supported
     for (const group of this.testGroups) {
       if (group.length > 1) {
@@ -211,13 +215,13 @@ export class ItemModelBuilder extends ItemPredicateClass {
       const value = countTest.value as { min?: number; max?: number } | number | undefined
 
       // Build entries from count range
-      const entries: Array<{ threshold: NBTFloat; model: ItemModel }> = []
+      const entries: Array<{ threshold: number; model: JSONItemModel }> = []
 
       if (typeof value === 'number') {
-        entries.push({ threshold: NBT.float(value), model: this.onTrueModel || { type: 'empty' } })
+        entries.push({ threshold: value, model: this.onTrueModel || { type: 'empty' } })
       } else if (value && typeof value === 'object') {
         if (value.min !== undefined) {
-          entries.push({ threshold: NBT.float(value.min), model: this.onTrueModel || { type: 'empty' } })
+          entries.push({ threshold: value.min, model: this.onTrueModel || { type: 'empty' } })
         }
       }
 
@@ -226,17 +230,17 @@ export class ItemModelBuilder extends ItemPredicateClass {
         property: 'count',
         entries,
         fallback: this.onFalseModel || { type: 'empty' },
-      } as ItemModel
+      } as JSONItemModel
     }
 
     // Build nested conditions from predicates
-    const onTrue = this.onTrueModel || { type: 'empty' } as ItemModel
-    const onFalse = this.onFalseModel || { type: 'empty' } as ItemModel
+    const onTrue = this.onTrueModel || { type: 'empty' } as JSONItemModel
+    const onFalse = this.onFalseModel || { type: 'empty' } as JSONItemModel
 
     return this.buildNestedConditions(0, onTrue, onFalse)
   }
 
-  private buildNestedConditions(index: number, onTrue: ItemModel, onFalse: ItemModel): ItemModel {
+  private buildNestedConditions(index: number, onTrue: JSONItemModel, onFalse: JSONItemModel): JSONItemModel {
     if (index >= this.testGroups.length) {
       return onTrue
     }
@@ -249,9 +253,9 @@ export class ItemModelBuilder extends ItemPredicateClass {
 
   private testToCondition(
     test: { negated: boolean; component: string; operator: string; value?: unknown },
-    onTrue: ItemModel,
-    onFalse: ItemModel,
-  ): ItemModel {
+    onTrue: JSONItemModel,
+    onFalse: JSONItemModel,
+  ): JSONItemModel {
     // Handle negation by swapping branches
     const [trueModel, falseModel] = test.negated ? [onFalse, onTrue] : [onTrue, onFalse]
 
@@ -263,7 +267,7 @@ export class ItemModelBuilder extends ItemPredicateClass {
           component: test.component,
           on_true: trueModel,
           on_false: falseModel,
-        } as ItemModel
+        } as JSONItemModel
 
       case '=':
       case '~':
@@ -275,7 +279,7 @@ export class ItemModelBuilder extends ItemPredicateClass {
           value: test.value,
           on_true: trueModel,
           on_false: falseModel,
-        } as ItemModel
+        } as JSONItemModel
 
       default:
         throw new Error(`Unknown predicate operator: ${test.operator}`)
@@ -295,8 +299,8 @@ export class ItemModelDefinitionNode extends ContainerNode implements ResourceNo
 }
 
 export type ItemModelDefinitionInput =
-  | ItemDefinition
-  | ItemModel
+  | JSONItemDefinition
+  | JSONItemModel
   | ItemModelBuilder
   | ((builder: ItemModelBuilder) => ItemModelBuilder)
 
@@ -311,7 +315,7 @@ export type ItemModelDefinitionClassArguments = {
 export class ItemModelDefinitionClass extends ResourceClass<ItemModelDefinitionNode> {
   static readonly resourceType = 'item_definition'
 
-  itemDefinitionJSON: ItemDefinition
+  itemDefinitionJSON: JSONItemDefinition
 
   constructor(
     core: SandstoneCore,
@@ -331,7 +335,7 @@ export class ItemModelDefinitionClass extends ResourceClass<ItemModelDefinitionN
     this.handleConflicts()
   }
 
-  private resolveDefinitionInput(input: ItemModelDefinitionInput): ItemDefinition {
+  private resolveDefinitionInput(input: ItemModelDefinitionInput): JSONItemDefinition {
     // Callback
     if (typeof input === 'function') {
       const builder = new ItemModelBuilder(this.core.pack)
@@ -343,10 +347,10 @@ export class ItemModelDefinitionClass extends ResourceClass<ItemModelDefinitionN
     }
     // Full ItemModelDefinition JSON (has 'model' property that is an object with 'type')
     if (input && 'model' in input && input.model && typeof input.model === 'object' && 'type' in input.model) {
-      return input as ItemDefinition
+      return input as JSONItemDefinition
     }
     // Raw ItemModel JSON (wrap in definition)
-    return { model: input as ItemModel }
+    return { model: input as JSONItemModel }
   }
 
   toString = () => `${this.path[0]}:${this.path.slice(2).join('/')}`

package/src/core/resources/resourcepack/model.ts

@@ -1,13 +1,14 @@
+import { LiteralUnion } from 'sandstone'
 import { ContainerNode } from '../../nodes'
 import type { SandstoneCore } from '../../sandstoneCore'
 import type { ResourceClassArguments, ResourceNode } from '../resource'
 import { ResourceClass, jsonStringify } from '../resource'
-import { RESOURCE_PATHS, type SymbolResource } from 'sandstone/arguments'
+import { RESOURCE_PATHS, type MCDocToJSON, type SymbolResource } from 'sandstone/arguments'
 
-export class ModelNode extends ContainerNode implements ResourceNode<ModelClass> {
+export class ModelNode<Type extends LiteralUnion<'block' | 'item'>> extends ContainerNode implements ResourceNode<ModelClass<Type>> {
   constructor(
     sandstoneCore: SandstoneCore,
-    public resource: ModelClass,
+    public resource: ModelClass<Type>,
   ) {
     super(sandstoneCore)
   }
@@ -19,20 +20,21 @@ export type ModelClassArguments = {
   /**
    * The model's JSON.
    */
-  json: SymbolResource[(typeof ModelClass)['resourceType']]
+  json: MCDocToJSON<SymbolResource[(typeof ModelClass)['resourceType']]>
 } & ResourceClassArguments<'default'>
 
+
 /**
  * Helper class for modifying Minecraft model data
  */
-export class ModelClass extends ResourceClass<ModelNode> {
+export class ModelClass<Type extends LiteralUnion<'block' | 'item'>> extends ResourceClass<ModelNode<Type>> {
   static readonly resourceType = 'model'
 
   modelJSON: NonNullable<ModelClassArguments['json']>
 
   constructor(
     core: SandstoneCore,
-    public type: 'block' | 'item',
+    public type: Type,
     name: string,
     args: ModelClassArguments,
   ) {
@@ -54,5 +56,5 @@ export class ModelClass extends ResourceClass<ModelNode> {
 
   // TODO: Consider building a separate Variable class for model manipulation
 
-  toString = () => `${this.path[0]}:${this.path.slice(2)}`
+  toString = () => `${this.path[0]}:${this.path.slice(2).join('/')}`
 }

package/src/core/resources/resourcepack/particle.ts

@@ -1,4 +1,4 @@
-import { RESOURCE_PATHS, type SymbolResource } from 'sandstone/arguments'
+import { RESOURCE_PATHS, type MCDocToJSON, type SymbolResource } from 'sandstone/arguments'
 import { ContainerNode } from '../../nodes'
 import type { SandstoneCore } from '../../sandstoneCore'
 import type { ResourceClassArguments, ResourceNode } from '../resource'
@@ -22,7 +22,7 @@ export type ParticleClassArguments = {
   /**
    * The particle's JSON.
    */
-  json: SymbolResource[(typeof ParticleClass)['resourceType']]
+  json: MCDocToJSON<SymbolResource[(typeof ParticleClass)['resourceType']]>
 } & ResourceClassArguments<'default'>
 
 export class ParticleClass extends ResourceClass<ParticleNode> {

package/src/core/resources/resourcepack/postEffect.ts

@@ -1,4 +1,4 @@
-import { RESOURCE_PATHS, type SymbolResource } from 'sandstone/arguments'
+import { RESOURCE_PATHS, type MCDocToJSON, type SymbolResource } from 'sandstone/arguments'
 import { ContainerNode } from '../../nodes'
 import type { SandstoneCore } from '../../sandstoneCore'
 import type { ResourceClassArguments, ResourceNode } from '../resource'
@@ -22,7 +22,7 @@ export type PostEffectClassArguments = {
   /**
    * The post effect's JSON.
    */
-  json: SymbolResource[(typeof PostEffectClass)['resourceType']]
+  json: MCDocToJSON<SymbolResource[(typeof PostEffectClass)['resourceType']]>
 } & ResourceClassArguments<'default'>
 
 export class PostEffectClass extends ResourceClass<PostEffectNode> {

package/src/core/resources/resourcepack/shader.ts

@@ -1,4 +1,4 @@
-import { RESOURCE_PATHS, type SymbolResource } from 'sandstone/arguments'
+import { RESOURCE_PATHS, type MCDocToJSON, type SymbolResource } from 'sandstone/arguments'
 import { ContainerNode } from '../../nodes'
 import type { SandstoneCore } from '../../sandstoneCore'
 import type { ResourceClassArguments, ResourceNode } from '../resource'
@@ -22,7 +22,7 @@ export type ShaderClassArguments = {
   /**
    * The shader's JSON.
    */
-  json: SymbolResource[(typeof ShaderClass)['resourceType']]
+  json: MCDocToJSON<SymbolResource[(typeof ShaderClass)['resourceType']]>
 } & ResourceClassArguments<'default'>
 
 export class ShaderClass extends ResourceClass<ShaderNode> {

package/src/core/resources/resourcepack/sound.ts

@@ -1,5 +1,5 @@
 import path from 'node:path'
-import { RESOURCE_PATHS, type SymbolResource, type SOUND_TYPES } from 'sandstone/arguments'
+import { RESOURCE_PATHS, type MCDocToJSON, type SymbolResource, type SOUND_TYPES } from 'sandstone/arguments'
 import { ContainerNode } from '../../nodes'
 import type { SandstoneCore } from '../../sandstoneCore'
 import type { ListResource, ResourceClassArguments, ResourceNode } from '../resource'
@@ -25,7 +25,7 @@ export type SoundEventArguments = {
   /**
    * The sound's buffer. Path string in `./resources` will be used. Defaults to `/resources/resourcepack/assets/(namespace)/sounds/(type)/(name)`.
    */
-  sound?: string | Promise<Buffer> | Buffer
+  sound?: string | ArrayBuffer | Buffer | Promise<ArrayBuffer | Buffer>
 
   /**
    * Whether to automatically add this to a sounds.json file. Defaults to false.
@@ -36,7 +36,7 @@ export type SoundEventArguments = {
 export class SoundEventClass<Type extends SOUND_TYPES = SOUND_TYPES> extends ResourceClass<SoundEventNode<Type>> {
   static readonly resourceType = 'sound'
 
-  buffer?: Promise<Buffer> | Buffer
+  buffer?: Promise<ArrayBuffer | Buffer> | ArrayBuffer | Buffer
 
   constructor(
     core: SandstoneCore,
@@ -67,7 +67,7 @@ export class SoundEventClass<Type extends SOUND_TYPES = SOUND_TYPES> extends Res
           def = this.core.sounds
             .set(
               this.path[0],
-              new SoundsClass(this.core, this.path[0], {
+              new SoundsIndexClass(this.core, this.path[0], {
                 addToSandstoneCore: true,
                 creator: 'sandstone',
               }),
@@ -88,12 +88,12 @@ export class SoundEventClass<Type extends SOUND_TYPES = SOUND_TYPES> extends Res
 }
 
 /**
- * A node representing a Minecraft sound.
+ * A node representing a Minecraft sounds index.
  */
-export class SoundsNode extends ContainerNode implements ResourceNode<SoundsClass> {
+export class SoundsIndexNode extends ContainerNode implements ResourceNode<SoundsIndexClass> {
   constructor(
     sandstoneCore: SandstoneCore,
-    public resource: SoundsClass,
+    public resource: SoundsIndexClass,
   ) {
     super(sandstoneCore)
   }
@@ -101,27 +101,27 @@ export class SoundsNode extends ContainerNode implements ResourceNode<SoundsClas
   getValue = () => jsonStringify(this.resource.soundsJSON, this.resource._resourceType as keyof typeof RESOURCE_PATHS)
 }
 
-type SoundsJSON = NonNullable<SymbolResource['sounds']>
+type SoundsJSON = NonNullable<MCDocToJSON<SymbolResource['sounds']>>
 
-export type SoundsArguments = {
+export type SoundsIndexArguments = {
   /**
    * The sounds definition map.
    */
   definitions?: SoundsJSON
 } & ResourceClassArguments<'default'>
 
-export class SoundsClass extends ResourceClass<SoundsNode> implements ListResource {
+export class SoundsIndexClass extends ResourceClass<SoundsIndexNode> implements ListResource {
   static readonly resourceType = 'sounds'
 
   soundsJSON: SoundsJSON | Promise<SoundsJSON>
 
-  constructor(core: SandstoneCore, namespace: string, args: SoundsArguments) {
+  constructor(core: SandstoneCore, namespace: string, args: SoundsIndexArguments) {
     super(
       core,
       { packType: core.pack.resourcePack() },
-      SoundsNode,
-      SoundsClass.resourceType,
-      core.pack.resourceToPath(`${namespace}:sounds`, RESOURCE_PATHS[SoundsClass.resourceType].path),
+      SoundsIndexNode,
+      SoundsIndexClass.resourceType,
+      core.pack.resourceToPath(`${namespace}:sounds`, RESOURCE_PATHS[SoundsIndexClass.resourceType].path),
       args,
     )
 
@@ -132,10 +132,10 @@ export class SoundsClass extends ResourceClass<SoundsNode> implements ListResour
     }
   }
 
-  async push(...soundEvents: SoundsClass[] | SoundEventClass<SOUND_TYPES>[]) {
-    if (soundEvents[0] instanceof SoundsClass) {
+  async push(...soundEvents: SoundsIndexClass[] | SoundEventClass<SOUND_TYPES>[]) {
+    if (soundEvents[0] instanceof SoundsIndexClass) {
       for await (const _sounds of soundEvents) {
-        const def = await (_sounds as SoundsClass).soundsJSON
+        const def = await (_sounds as SoundsIndexClass).soundsJSON
         const s = await this.soundsJSON
 
         // TODO: Implement sound event merging
@@ -154,10 +154,10 @@ export class SoundsClass extends ResourceClass<SoundsNode> implements ListResour
     }
   }
 
-  async unshift(...soundEvents: SoundsClass[] | SoundEventClass<SOUND_TYPES>[]) {
-    if (soundEvents[0] instanceof SoundsClass) {
+  async unshift(...soundEvents: SoundsIndexClass[] | SoundEventClass<SOUND_TYPES>[]) {
+    if (soundEvents[0] instanceof SoundsIndexClass) {
       for await (const _sounds of soundEvents) {
-        const def = await (_sounds as SoundsClass).soundsJSON
+        const def = await (_sounds as SoundsIndexClass).soundsJSON
         const s = await this.soundsJSON
 
         // TODO: Implement sound event merging

package/src/core/resources/resourcepack/text.ts

@@ -1,6 +1,6 @@
 /* eslint-disable no-lone-blocks */
 
-import type { ContentTag, JSONTextComponent } from 'sandstone/arguments'
+import type { JSONTextComponent } from 'sandstone/arguments'
 import { JSONTextComponentClass } from 'sandstone/variables'
 import { ContainerNode } from '../../nodes'
 import type { SandstoneCore } from '../../sandstoneCore'
@@ -71,60 +71,62 @@ export class PlainTextClass extends ResourceClass<PlainTextNode> implements List
         converted += this.componentToPlainText(_text)
       }
     } else {
-      const currentText = text as ContentTag<'text'>
+      const currentText = text
 
-      if (!currentText.text) {
-        throw new Error('Dynamic JSON content is not supported in plaintext')
-      }
+      if (typeof currentText !== 'string') {
+        if (!('text' in currentText)) {
+          throw new Error('Dynamic JSON content is not supported in plaintext')
+        }
 
-      if (currentText.color) {
-        const { color } = currentText
-        if (color.startsWith('#')) {
-          throw new Error('Hex codes are not supported in plaintext')
+        if (currentText.color) {
+          const { color } = currentText
+          if (color.startsWith('#')) {
+            throw new Error('Hex codes are not supported in plaintext')
+          }
+          // eslint-disable-next-line max-len
+          const colors = [
+            'black',
+            'dark_blue',
+            'dark_green',
+            'dark_aqua',
+            'dark_red',
+            'dark_purple',
+            'gold',
+            'gray',
+            'dark_gray',
+            'blue',
+            'green',
+            'aqua',
+            'red',
+            'light_purple',
+            'yellow',
+            'white',
+          ] as const
+
+          converted = `§${colors.indexOf(color as 'black').toString(16)}`
         }
-        // eslint-disable-next-line max-len
-        const colors = [
-          'black',
-          'dark_blue',
-          'dark_green',
-          'dark_aqua',
-          'dark_red',
-          'dark_purple',
-          'gold',
-          'gray',
-          'dark_gray',
-          'blue',
-          'green',
-          'aqua',
-          'red',
-          'light_purple',
-          'yellow',
-          'white',
-        ] as const
-
-        converted = `§${colors.indexOf(color as 'black').toString(16)}`
-      }
 
-      if (currentText.obfuscated) {
-        converted += '§k'
-      }
-      if (currentText.bold) {
-        converted += '§l'
-      }
-      if (currentText.strikethrough) {
-        converted += '§m'
-      }
-      if (currentText.underlined) {
-        converted += '§n'
-      }
-      if (currentText.italic) {
-        converted += '§o'
-      }
+        if (currentText.obfuscated) {
+          converted += '§k'
+        }
+        if (currentText.bold) {
+          converted += '§l'
+        }
+        if (currentText.strikethrough) {
+          converted += '§m'
+        }
+        if (currentText.underlined) {
+          converted += '§n'
+        }
+        if (currentText.italic) {
+          converted += '§o'
+        }
 
-      converted += `${currentText.text}`
+        converted += `${currentText.text}`
 
-      if (currentText.extra) {
-        converted += this.componentToPlainText(currentText.extra)
+        if (currentText.extra) {
+          converted += this.componentToPlainText(currentText.extra as JSONTextComponent)
+        }
       }
     }
 

package/src/core/resources/resourcepack/texture.ts

@@ -1,4 +1,4 @@
-import { RESOURCE_PATHS, type SymbolResource, type TEXTURE_TYPES } from 'sandstone/arguments'
+import { RESOURCE_PATHS, type MCDocToJSON, type SymbolResource, type TEXTURE_TYPES } from 'sandstone/arguments'
 import type { LiteralUnion } from 'sandstone/utils'
 import { ContainerNode } from '../../nodes'
 import type { SandstoneCore } from '../../sandstoneCore'
@@ -7,7 +7,7 @@ import { ResourceClass } from '../resource'
 
 type TextureType = LiteralUnion<TEXTURE_TYPES>
 
-type TextureMetaAll = SymbolResource['texture_meta']
+type TextureMetaAll = MCDocToJSON<SymbolResource['texture_meta']>
 
 // TODO: Find which texture types actually support animations.
 type TextureMeta<Type extends TextureType> = (
@@ -35,14 +35,14 @@ export type TextureArguments<Type extends TextureType> = {
   /**
    * The texture's buffer.
    */
-  texture?: Promise<Buffer> | Buffer
+  texture?: Promise<ArrayBuffer | Buffer> | ArrayBuffer | Buffer
 
   sprite?: boolean | string
 
   meta?: TextureMeta<Type>
 } & ResourceClassArguments<'default'>
 
-export class TextureClass<Type extends TextureType = 'block'> extends ResourceClass<TextureNode<Type>> {
+export class TextureClass<Type extends TextureType> extends ResourceClass<TextureNode<Type>> {
   static readonly resourceType = 'texture'
 
   type: Type
@@ -81,7 +81,7 @@ export class TextureClass<Type extends TextureType = 'block'> extends ResourceCl
   }
 
   toString() {
-    return `${this.path[0]}:${this.path.slice(2)}`
+    return `${this.path[0]}:${this.path.slice(2).join('/')}`
   }
 
   // TODO

package/src/core/resources/resourcepack/waypointStyle.ts

@@ -1,4 +1,4 @@
-import { RESOURCE_PATHS, type SymbolResource } from 'sandstone/arguments'
+import { RESOURCE_PATHS, type MCDocToJSON, type SymbolResource } from 'sandstone/arguments'
 import { ContainerNode } from '../../nodes'
 import type { SandstoneCore } from '../../sandstoneCore'
 import type { ResourceClassArguments, ResourceNode } from '../resource'
@@ -22,7 +22,7 @@ export type WaypointStyleClassArguments = {
   /**
    * The waypoint style's JSON.
    */
-  json: SymbolResource[(typeof WaypointStyleClass)['resourceType']]
+  json: MCDocToJSON<SymbolResource[(typeof WaypointStyleClass)['resourceType']]>
 } & ResourceClassArguments<'default'>
 
 export class WaypointStyleClass extends ResourceClass<WaypointStyleNode> {