sandstone 1.1.1 → 1.1.3

package/src/core/resources/datapack/trimMaterial.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'
@@ -23,7 +23,7 @@ export type TrimMaterialClassArguments = {
   /**
    * The trim material's JSON.
    */
-  json: SymbolResource[(typeof TrimMaterialClass)['resourceType']]
+  json: MCDocToJSON<SymbolResource[(typeof TrimMaterialClass)['resourceType']]>
 } & ResourceClassArguments<'default'>
 
 export class TrimMaterialClass extends ResourceClass<TrimMaterialNode> {

package/src/core/resources/datapack/trimPattern.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'
@@ -23,7 +23,7 @@ export type TrimPatternClassArguments = {
   /**
    * The trim pattern's JSON.
    */
-  json: SymbolResource[(typeof TrimPatternClass)['resourceType']]
+  json: MCDocToJSON<SymbolResource[(typeof TrimPatternClass)['resourceType']]>
 } & ResourceClassArguments<'default'>
 
 export class TrimPatternClass extends ResourceClass<TrimPatternNode> {

package/src/core/resources/datapack/variant.ts

@@ -1,4 +1,4 @@
-import { type RESOURCE_PATHS, type SymbolResource } from 'sandstone/arguments'
+import { type RESOURCE_PATHS, type MCDocToJSON, type SymbolResource } from 'sandstone/arguments'
 import { ContainerNode } from '../../nodes'
 import type { SandstoneCore } from '../../sandstoneCore'
 import type { ResourceClassArguments, ResourceNode } from '../resource'
@@ -31,7 +31,7 @@ type VariantSymbolKey<T extends VariantType> = `${T}_variant`
 /**
  * Gets the JSON type for a variant from SymbolResource.
  */
-type VariantJSON<T extends VariantType> = SymbolResource[VariantSymbolKey<T>]
+type VariantJSON<T extends VariantType> = MCDocToJSON<SymbolResource[VariantSymbolKey<T>]>
 
 /**
  * A node representing a Minecraft entity variant.

package/src/core/resources/datapack/villagerTrade.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 VillagerTradeClassArguments = {
   /**
    * The villager trade's JSON.
    */
-  json: SymbolResource[(typeof VillagerTradeClass)['resourceType']]
+  json: MCDocToJSON<SymbolResource[(typeof VillagerTradeClass)['resourceType']]>
 } & ResourceClassArguments<'default'>
 
 export class VillagerTradeClass extends ResourceClass<VillagerTradeNode> {
@@ -64,7 +64,7 @@ export type TradeSetClassArguments = {
   /**
    * The trade set's JSON.
    */
-  json: SymbolResource[(typeof TradeSetClass)['resourceType']]
+  json: MCDocToJSON<SymbolResource[(typeof TradeSetClass)['resourceType']]>
 } & ResourceClassArguments<'default'>
 
 export class TradeSetClass extends ResourceClass<TradeSetNode> {

package/src/core/resources/resource.ts

@@ -185,11 +185,8 @@ export abstract class ResourceClass<N extends ResourceNode = ResourceNode<any>>
     return this.name
   }
 
-  /**
-   * @internal
-   */
   toNBT(): string {
-    return this.name
+    return `'${this.name}'`
   }
 
   /**

package/src/core/resources/resourcepack/atlas.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 { ListResource, ResourceClassArguments, ResourceNode } from '../resource'
@@ -23,7 +23,7 @@ export type AtlasClassArguments = {
   /**
    * The atlas JSON.
    */
-  json?: SymbolResource[(typeof AtlasClass)['resourceType']]
+  json?: MCDocToJSON<SymbolResource[(typeof AtlasClass)['resourceType']]>
 } & ResourceClassArguments<'list'>
 
 export class AtlasClass extends ResourceClass<AtlasNode> implements ListResource {
@@ -46,7 +46,7 @@ export class AtlasClass extends ResourceClass<AtlasNode> implements ListResource
     this.handleConflicts()
   }
 
-  push(...sources: SpriteSource[] | AtlasClass[]) {
+  push(...sources: MCDocToJSON<SpriteSource>[] | AtlasClass[]) {
     if (sources[0] instanceof AtlasClass) {
       for (const provider of sources) {
         /** @ts-ignore */
@@ -58,7 +58,7 @@ export class AtlasClass extends ResourceClass<AtlasNode> implements ListResource
     }
   }
 
-  unshift(...sources: SpriteSource[] | AtlasClass[]) {
+  unshift(...sources: MCDocToJSON<SpriteSource>[] | AtlasClass[]) {
     if (sources[0] instanceof AtlasClass) {
       for (const provider of sources) {
         /** @ts-ignore */

package/src/core/resources/resourcepack/blockstate.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'
@@ -6,7 +6,7 @@ import type { ListResource, ResourceClassArguments, ResourceNode } from '../reso
 import { ResourceClass, jsonStringify } from '../resource'
 import type { AllKeys } from 'sandstone/utils'
 
-export type BlockStateJSON = NonNullable<SymbolResource['block_definition']>
+export type BlockStateJSON = NonNullable<MCDocToJSON<SymbolResource['block_definition']>>
 export type BlockStateType = AllKeys<BlockStateJSON>
 
 /**

package/src/core/resources/resourcepack/equipment.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 EquipmentClassArguments = {
   /**
    * The equipment's JSON.
    */
-  json: SymbolResource[(typeof EquipmentClass)['resourceType']]
+  json: MCDocToJSON<SymbolResource[(typeof EquipmentClass)['resourceType']]>
 } & ResourceClassArguments<'default'>
 
 export class EquipmentClass extends ResourceClass<EquipmentNode> {

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

@@ -1,4 +1,4 @@
-import { RESOURCE_PATHS } from 'sandstone/arguments'
+import { type MCDocToJSON, RESOURCE_PATHS } from 'sandstone/arguments'
 import type { GlyphProvider } from 'sandstone/arguments/generated/assets/font'
 import { ContainerNode } from '../../nodes'
 import type { SandstoneCore } from '../../sandstoneCore'
@@ -23,7 +23,7 @@ export type FontArguments = {
   /**
    * The font's JSON.
    */
-  providers: GlyphProvider[] | []
+  providers: MCDocToJSON<GlyphProvider>[] | []
 } & ResourceClassArguments<'list'>
 
 export class FontClass extends ResourceClass<FontNode> implements ListResource {
@@ -46,7 +46,7 @@ export class FontClass extends ResourceClass<FontNode> implements ListResource {
     this.handleConflicts()
   }
 
-  push(...providers: GlyphProvider[] | FontClass[]) {
+  push(...providers: MCDocToJSON<GlyphProvider>[] | FontClass[]) {
     if (providers[0] instanceof FontClass) {
       for (const provider of providers) {
         /** @ts-ignore */
@@ -58,7 +58,7 @@ export class FontClass extends ResourceClass<FontNode> implements ListResource {
     }
   }
 
-  unshift(...providers: GlyphProvider[] | FontClass[]) {
+  unshift(...providers: MCDocToJSON<GlyphProvider>[] | FontClass[]) {
     if (providers[0] instanceof FontClass) {
       for (const provider of providers) {
         /** @ts-ignore */

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