sandstone 1.1.3 → 1.2.0

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

@@ -6,115 +6,115 @@ import type { ListResource, ResourceClassArguments, ResourceNode } from '../reso
 import { ResourceClass, jsonStringify } from '../resource'
 import type { AllKeys } from 'sandstone/utils'
 
-export type BlockStateJSON = NonNullable<MCDocToJSON<SymbolResource['block_definition']>>
-export type BlockStateType = AllKeys<BlockStateJSON>
+export type BlockStateDefinitionJSON = NonNullable<MCDocToJSON<SymbolResource['block_definition']>>
+export type BlockStateDefinitionType = AllKeys<BlockStateDefinitionJSON>
 
 /**
- * A node representing a Minecraft block state.
+ * A node representing a Minecraft block state definition.
  */
-export class BlockStateNode<JSON extends BlockStateJSON>
+export class BlockStateDefinitionNode<JSON extends BlockStateDefinitionJSON>
   extends ContainerNode
-  implements ResourceNode<BlockStateClass<JSON>> {
+  implements ResourceNode<BlockStateDefinitionClass<JSON>> {
   constructor(
     sandstoneCore: SandstoneCore,
-    public resource: BlockStateClass<JSON>,
+    public resource: BlockStateDefinitionClass<JSON>,
   ) {
     super(sandstoneCore)
   }
 
-  getValue = () => jsonStringify(this.resource.blockStateJSON, this.resource._resourceType as keyof typeof RESOURCE_PATHS)
+  getValue = () => jsonStringify(this.resource.blockStateDefinitionJSON, this.resource._resourceType as keyof typeof RESOURCE_PATHS)
 }
 
-export type BlockStateArguments<JSON extends BlockStateJSON> = {
+export type BlockStateDefinitionArguments<JSON extends BlockStateDefinitionJSON> = {
   /**
-   * The block state's JSON.
+   * The block state definition's JSON.
    */
   json: JSON
 } & ResourceClassArguments<'list'>
 
-export class BlockStateClass<JSON extends BlockStateJSON, Type = Extract<AllKeys<JSON>, BlockStateType>>
-  extends ResourceClass<BlockStateNode<JSON>>
+export class BlockStateDefinitionClass<JSON extends BlockStateDefinitionJSON, Type = Extract<AllKeys<JSON>, BlockStateDefinitionType>>
+  extends ResourceClass<BlockStateDefinitionNode<JSON>>
   implements ListResource {
   static readonly resourceType = 'block_definition'
 
-  blockStateJSON: JSON
+  blockStateDefinitionJSON: JSON
 
   type: Type
 
   constructor(
     core: SandstoneCore,
     name: string,
-    args: BlockStateArguments<JSON>,
+    args: BlockStateDefinitionArguments<JSON>,
   ) {
     super(
       core,
       { packType: core.pack.resourcePack() },
-      BlockStateNode,
-      BlockStateClass.resourceType,
-      core.pack.resourceToPath(name, RESOURCE_PATHS[BlockStateClass.resourceType].path),
+      BlockStateDefinitionNode,
+      BlockStateDefinitionClass.resourceType,
+      core.pack.resourceToPath(name, RESOURCE_PATHS[BlockStateDefinitionClass.resourceType].path),
       args,
     )
 
-    this.blockStateJSON = args.json
+    this.blockStateDefinitionJSON = args.json
 
-    this.type = Object.keys(this.blockStateJSON)[0] as Type
+    this.type = Object.keys(this.blockStateDefinitionJSON)[0] as Type
 
     this.handleConflicts()
   }
 
-  push(...states: BlockStateClass<any, Type>[] | BlockStateJSON[]) {
+  push(...states: BlockStateDefinitionClass<any, Type>[] | BlockStateDefinitionJSON[]) {
     if (this.type === 'variants') {
-      if (states[0] instanceof BlockStateClass) {
+      if (states[0] instanceof BlockStateDefinitionClass) {
         for (const state of states) {
           /** @ts-ignore */
-          this.blockStateJSON.variants = { ...this.blockStateJSON.variants, ...state.blockStateJSON.variants }
+          this.blockStateDefinitionJSON.variants = { ...this.blockStateDefinitionJSON.variants, ...state.blockStateDefinitionJSON.variants }
         }
       } else {
         for (const state of states) {
           /** @ts-ignore */
-          this.blockStateJSON.variants = { ...this.blockStateJSON.variants, ...state.variants }
+          this.blockStateDefinitionJSON.variants = { ...this.blockStateDefinitionJSON.variants, ...state.variants }
         }
       }
     }
     if (this.type === 'multipart') {
-      if (states[0] instanceof BlockStateClass) {
+      if (states[0] instanceof BlockStateDefinitionClass) {
         for (const state of states) {
           /** @ts-ignore */
-          this.blockStateJSON.multipart.push(...state.blockStateJSON.multipart)
+          this.blockStateDefinitionJSON.multipart.push(...state.blockStateDefinitionJSON.multipart)
         }
       } else {
         for (const state of states) {
           /** @ts-ignore */
-          this.blockStateJSON.multipart.push(...state.multipart)
+          this.blockStateDefinitionJSON.multipart.push(...state.multipart)
         }
       }
     }
   }
 
-  unshift(...states: BlockStateClass<any, Type>[] | BlockStateJSON[]) {
+  unshift(...states: BlockStateDefinitionClass<any, Type>[] | BlockStateDefinitionJSON[]) {
     if (this.type === 'variants') {
-      if (states[0] instanceof BlockStateClass) {
+      if (states[0] instanceof BlockStateDefinitionClass) {
         for (const state of states) {
           /** @ts-ignore */
-          this.blockStateJSON.variants = { ...state.blockStateJSON.variants, ...this.blockStateJSON.variants }
+          this.blockStateDefinitionJSON.variants = { ...state.blockStateDefinitionJSON.variants, ...this.blockStateDefinitionJSON.variants }
         }
       } else {
         for (const state of states) {
           /** @ts-ignore */
-          this.blockStateJSON.variants = { ...state.variants, ...this.blockStateJSON.variants }
+          this.blockStateDefinitionJSON.variants = { ...state.variants, ...this.blockStateDefinitionJSON.variants }
         }
       }
     }
     if (this.type === 'multipart') {
-      if (states[0] instanceof BlockStateClass) {
+      if (states[0] instanceof BlockStateDefinitionClass) {
         for (const state of states) {
           /** @ts-ignore */
-          this.blockStateJSON.multipart.unshift(...state.blockStateJSON.multipart)
+          this.blockStateDefinitionJSON.multipart.unshift(...state.blockStateDefinitionJSON.multipart)
         }
       } else {
         for (const state of states) {
           /** @ts-ignore */
-          this.blockStateJSON.multipart.unshift(...state.multipart)
+          this.blockStateDefinitionJSON.multipart.unshift(...state.multipart)
         }
       }
     }

package/src/flow/Flow.ts

@@ -1,8 +1,6 @@
 import type {
   Registry,
-  ContainerSlotSelector,
   Coordinates,
-  EntitySlotSelector,
   JSONTextComponent,
   MultipleEntitiesArgument,
   MultiplePlayersArgument,
@@ -11,6 +9,7 @@ import type {
   SymbolBlock,
   SymbolMcdocBlockStates,
 } from 'sandstone/arguments'
+import type { ItemSlotSource } from '../commands/implementations/world/item'
 import type {
   ConditionClass,
   DataPointClass,
@@ -21,7 +20,7 @@ import type {
 import { parseJSONText, Score } from 'sandstone/variables'
 import type { DataPointPickClass, MCFunctionClass, PredicateClass, SandstoneCore } from '../core'
 import type { LiteralUnion, NamespacedLiteralUnion } from '../utils'
-import { AndNode, ConditionNode, NotNode, OrNode, SandstoneConditions, type BlockConditionNode, type ItemsBlockConditionNode, type ItemsEntityConditionNode } from './conditions'
+import { AndNode, ConditionNode, NotNode, OrNode, SandstoneConditions, type BlockConditionNode, type ItemsBlockConditionNode, type ItemsEntityConditionNode, type SlotsBlockConditionNode, type SlotsEntityConditionNode } from './conditions'
 import type { ItemPredicate } from './conditions/variables/items'
 import { IfStatement } from './if_else'
 import type { ForOfIterator } from './loops'
@@ -58,17 +57,37 @@ export class Flow {
   if = (condition: Condition, callback: () => void) =>
     new IfStatement(this.sandstoneCore, conditionToNode(condition), callback)
 
-  and = (...conditions: Condition[]) =>
-    new AndNode(
+  /**
+   * Combine conditions with AND.
+   *
+   * Accepts either variadic conditions (`_.and(a, b, c)`) or a single array
+   * (`_.and([a, b, c])`, useful for `Array.prototype.map` results).
+   */
+  and(...conditions: Condition[]): AndNode
+  and(conditions: Condition[]): AndNode
+  and(...args: any[]): AndNode {
+    const conditions = (args[0] instanceof Array ? args[0] : args) as Condition[]
+    return new AndNode(
       this.sandstoneCore,
       conditions.map((condition) => conditionToNode(condition)),
     )
+  }
 
-  or = (...conditions: Condition[]) =>
-    new OrNode(
+  /**
+   * Combine conditions with OR.
+   *
+   * Accepts either variadic conditions (`_.or(a, b, c)`) or a single array
+   * (`_.or([a, b, c])`, useful for `Array.prototype.map` results).
+   */
+  or(...conditions: Condition[]): OrNode
+  or(conditions: Condition[]): OrNode
+  or(...args: any[]): OrNode {
+    const conditions = (args[0] instanceof Array ? args[0] : args) as Condition[]
+    return new OrNode(
       this.sandstoneCore,
       conditions.map((condition) => conditionToNode(condition)),
     )
+  }
 
   not = (condition: Condition) => new NotNode(this.sandstoneCore, conditionToNode(condition))
 
@@ -466,24 +485,57 @@ export class Flow {
      * Test for items in a block entity's inventory slots.
      *
      * @param sourcePos Position of the block entity to test.
-     * @param slots Slots to test (e.g., `'container.*'`, `'container.0'`).
+     * @param slotSource Slot source to test (e.g., `'container.*'`, inline slot source, or a slot source reference).
      * @param itemPredicate Item predicate to match against.
      */
-    block: (sourcePos: Coordinates, slots: ContainerSlotSelector, itemPredicate: ItemPredicate) => ItemsBlockConditionNode
+    block: (sourcePos: Coordinates, slotSource: ItemSlotSource, itemPredicate: ItemPredicate) => ItemsBlockConditionNode
     /**
      * Test for items in an entity's inventory slots.
      *
      * @param source Entity to test.
-     * @param slots Slots to test (e.g., `'inventory.*'`, `'hotbar.0'`, `'armor.chest'`).
+     * @param slotSource Slot source to test (e.g., `'inventory.*'`, inline slot source, or a slot source reference).
      * @param itemPredicate Item predicate to match against.
      */
-    entity: (source: MultipleEntitiesArgument, slots: EntitySlotSelector, itemPredicate: ItemPredicate) => ItemsEntityConditionNode
+    entity: (source: MultipleEntitiesArgument, slotSource: ItemSlotSource, itemPredicate: ItemPredicate) => ItemsEntityConditionNode
+  } {
+    return {
+      block: (sourcePos: Coordinates, slotSource: ItemSlotSource, itemPredicate: ItemPredicate) =>
+        new SandstoneConditions.ItemsBlock(this.sandstoneCore, sourcePos, slotSource, itemPredicate),
+      entity: (source: MultipleEntitiesArgument, slotSource: ItemSlotSource, itemPredicate: ItemPredicate) =>
+        new SandstoneConditions.ItemsEntity(this.sandstoneCore, source, slotSource, itemPredicate),
+    }
+  }
+
+  /**
+   * Counts slots from a slot source that are present in a block entity or entity.
+   *
+   * @example
+   * ```ts
+   * _.if(_.slots.entity('@p', 'inventory.*'), () => { ... })
+   * _.if(_.slots.block(abs(0, 64, 0), { type: 'minecraft:slot_range', slots: 'armor.chest' }), () => { ... })
+   * ```
+   */
+  get slots(): {
+    /**
+     * Count slots from a slot source that are present in a block entity.
+     *
+     * @param sourcePos Position of the block entity to test.
+     * @param slotSource Slot source (e.g., `'container.*'`, inline slot source, or a slot source reference).
+     */
+    block: (sourcePos: Coordinates, slotSource: ItemSlotSource) => SlotsBlockConditionNode
+    /**
+     * Count slots from a slot source that are present in an entity.
+     *
+     * @param source Entity to test.
+     * @param slotSource Slot source (e.g., `'inventory.*'`, inline slot source, or a slot source reference).
+     */
+    entity: (source: MultipleEntitiesArgument, slotSource: ItemSlotSource) => SlotsEntityConditionNode
   } {
     return {
-      block: (sourcePos: Coordinates, slots: ContainerSlotSelector, itemPredicate: ItemPredicate) =>
-        new SandstoneConditions.ItemsBlock(this.sandstoneCore, sourcePos, slots, itemPredicate),
-      entity: (source: MultipleEntitiesArgument, slots: EntitySlotSelector, itemPredicate: ItemPredicate) =>
-        new SandstoneConditions.ItemsEntity(this.sandstoneCore, source, slots, itemPredicate),
+      block: (sourcePos: Coordinates, slotSource: ItemSlotSource) =>
+        new SandstoneConditions.SlotsBlock(this.sandstoneCore, sourcePos, slotSource),
+      entity: (source: MultipleEntitiesArgument, slotSource: ItemSlotSource) =>
+        new SandstoneConditions.SlotsEntity(this.sandstoneCore, source, slotSource),
     }
   }
 

package/src/flow/conditions/index.ts

@@ -11,6 +11,7 @@ import * as variables from './variables'
 export const SandstoneConditions = {
   Advancement: resources.AdvancementConditionNode,
   Predicate: resources.PredicateConditionNode,
+  SlotSource: resources.SlotSourceConditionNode,
   Tag: resources.TagConditionNode,
 
   Biome: variables.BiomeConditionNode,
@@ -20,6 +21,8 @@ export const SandstoneConditions = {
   Function: variables.FunctionConditionNode,
   ItemsBlock: variables.ItemsBlockConditionNode,
   ItemsEntity: variables.ItemsEntityConditionNode,
+  SlotsBlock: variables.SlotsBlockConditionNode,
+  SlotsEntity: variables.SlotsEntityConditionNode,
   Loaded: variables.LoadedConditionNode,
   DataPointExists: variables.DataPointExistsConditionNode,
   DataPointEquals: variables.DataPointEqualsConditionNode,

package/src/flow/conditions/resources/index.ts

@@ -1,3 +1,4 @@
 export * from './advancement'
 export * from './predicate'
+export * from './slotSource'
 export * from './tag'

package/src/flow/conditions/resources/slotSource.ts

@@ -0,0 +1,21 @@
+import type { SandstoneCore } from 'sandstone/core'
+import { SingleConditionNode } from '../condition'
+
+/**
+ * Condition node representing a slot source being tested against `@s`.
+ *
+ * Expands to `execute if slots entity @s <slotSource>`, which counts the number of slots from
+ * the slot source that are present on the executing entity.
+ */
+export class SlotSourceConditionNode extends SingleConditionNode {
+  constructor(
+    sandstoneCore: SandstoneCore,
+    public slotSource: string,
+  ) {
+    super(sandstoneCore)
+  }
+
+  getCondition(): unknown[] {
+    return ['slots', 'entity', '@s', this.slotSource]
+  }
+}

package/src/flow/conditions/variables/items.ts

@@ -1,7 +1,8 @@
-import type { Coordinates, ContainerSlotSelector, EntitySlotSelector, MultipleEntitiesArgument, Registry } from 'sandstone/arguments'
+import type { Coordinates, MultipleEntitiesArgument, Registry } from 'sandstone/arguments'
 import type { SandstoneCore } from 'sandstone/core/sandstoneCore'
 import { coordinatesParser, targetParser } from 'sandstone/variables'
 import type { ItemPredicateClass } from 'sandstone/variables/ItemPredicate'
+import type { ItemSlotSource } from '../../../commands/implementations/world/item'
 import { SingleConditionNode } from '../condition'
 
 /** Item predicate for matching items in inventory slots. */
@@ -14,20 +15,23 @@ export type ItemPredicate = Registry['minecraft:item'] | ItemPredicateClass
  * ```ts
  * // Check if chest has any diamonds
  * _.if(_.items.block(abs(0, 64, 0), 'container.*', 'minecraft:diamond'), () => { ... })
+ *
+ * // Check using an inline slot source
+ * _.if(_.items.block(abs(0, 64, 0), { type: 'minecraft:slot_range', slots: 'container.0' }, 'minecraft:diamond'), () => { ... })
  * ```
  */
 export class ItemsBlockConditionNode extends SingleConditionNode {
   constructor(
     sandstoneCore: SandstoneCore,
     private sourcePos: Coordinates,
-    private slots: ContainerSlotSelector,
+    private slotSource: ItemSlotSource,
     private itemPredicate: ItemPredicate,
   ) {
     super(sandstoneCore)
   }
 
   getCondition() {
-    return ['items', 'block', coordinatesParser(this.sourcePos), this.slots, `${this.itemPredicate}`]
+    return ['items', 'block', coordinatesParser(this.sourcePos), this.slotSource, `${this.itemPredicate}`]
   }
 }
 
@@ -44,13 +48,57 @@ export class ItemsEntityConditionNode extends SingleConditionNode {
   constructor(
     sandstoneCore: SandstoneCore,
     private source: MultipleEntitiesArgument,
-    private slots: EntitySlotSelector,
+    private slotSource: ItemSlotSource,
     private itemPredicate: ItemPredicate,
   ) {
     super(sandstoneCore)
   }
 
   getCondition() {
-    return ['items', 'entity', targetParser(this.source), this.slots, `${this.itemPredicate}`]
+    return ['items', 'entity', targetParser(this.source), this.slotSource, `${this.itemPredicate}`]
+  }
+}
+
+/**
+ * Condition node for counting slots from a slot source on a block entity.
+ *
+ * @example
+ * ```ts
+ * _.if(_.slots.block(abs(0, 64, 0), 'container.*'), () => { ... })
+ * ```
+ */
+export class SlotsBlockConditionNode extends SingleConditionNode {
+  constructor(
+    sandstoneCore: SandstoneCore,
+    private sourcePos: Coordinates,
+    private slotSource: ItemSlotSource,
+  ) {
+    super(sandstoneCore)
+  }
+
+  getCondition() {
+    return ['slots', 'block', coordinatesParser(this.sourcePos), this.slotSource]
+  }
+}
+
+/**
+ * Condition node for counting slots from a slot source on an entity.
+ *
+ * @example
+ * ```ts
+ * _.if(_.slots.entity('@p', 'inventory.*'), () => { ... })
+ * ```
+ */
+export class SlotsEntityConditionNode extends SingleConditionNode {
+  constructor(
+    sandstoneCore: SandstoneCore,
+    private source: MultipleEntitiesArgument,
+    private slotSource: ItemSlotSource,
+  ) {
+    super(sandstoneCore)
+  }
+
+  getCondition() {
+    return ['slots', 'entity', targetParser(this.source), this.slotSource]
   }
 }

package/src/pack/pack.ts

@@ -24,12 +24,12 @@ import type {
   AdvancementClassArguments,
   AtlasClassArguments,
   BannerPatternClassArguments,
-  BlockStateArguments,
-  BlockStateJSON,
+  BlockStateDefinitionArguments,
+  BlockStateDefinitionJSON,
   ChatTypeClassArguments,
   DamageTypeClassArguments,
   DataPointPickClass,
-//  DecoratedPotPatternClassArguments,
+  DecoratedPotPatternClassArguments,
   DialogClassArguments,
   EnchantmentClassArguments,
   EnchantmentProviderClassArguments,
@@ -52,7 +52,7 @@ import type {
   PredicateClassArguments,
   RecipeClassArguments,
   ShaderClassArguments,
-//  SlotSourceClassArguments,
+  SlotSourceClassArguments,
   SoundEventArguments,
   SoundsIndexArguments,
   SulfurCubeArchetypeClassArguments,
@@ -76,10 +76,10 @@ import {
   AdvancementClass,
   AtlasClass,
   BannerPatternClass,
-  BlockStateClass,
+  BlockStateDefinitionClass,
   ChatTypeClass,
   DamageTypeClass,
-//  DecoratedPotPatternClass,
+  DecoratedPotPatternClass,
   DialogClass,
   EnchantmentClass,
   EnchantmentProviderClass,
@@ -102,7 +102,7 @@ import {
   RecipeClass,
   SandstoneCore,
   ShaderClass,
-//  SlotSourceClass,
+  SlotSourceClass,
   SoundEventClass,
   SoundsIndexClass,
   SulfurCubeArchetypeClass,
@@ -140,9 +140,11 @@ import type {
 } from 'sandstone/variables'
 import {
   coordinatesParser,
-  DataArray,
+  DataArrayType,
+  DataArrayInternal,
   DataClass,
-  DataIndexMap,
+  DataIndexMapType,
+  DataIndexMapInternal,
   DataPointClass,
   ItemPredicateClass,
   LabelClass,
@@ -316,11 +318,11 @@ export class SandstonePack {
     }
     return {
       datapack: {
-        packFormat: 61,
+        packFormat: 112,
         description: 'A Sandstone datapack',
       },
       resourcepack: {
-        packFormat: 46,
+        packFormat: 93,
         description: 'A Sandstone resource pack',
       },
     }
@@ -446,7 +448,7 @@ export class SandstonePack {
     let pack = this.packTypes.get('datapack') as DataPack
 
     if (!pack) {
-      const options = this.packOptions.datapack ?? { packFormat: 98, description: 'A Sandstone datapack' }
+      const options = this.packOptions.datapack ?? { packFormat: 112, description: 'A Sandstone datapack' }
       pack = this.packTypes.set('datapack', new DataPack(false, options)).get('datapack') as DataPack
     }
 
@@ -457,7 +459,7 @@ export class SandstonePack {
     let pack = this.packTypes.get('resourcepack') as ResourcePack
 
     if (!pack) {
-      const options = this.packOptions.resourcepack ?? { packFormat: 79, description: 'A Sandstone resource pack' }
+      const options = this.packOptions.resourcepack ?? { packFormat: 93, description: 'A Sandstone resource pack' }
       pack = this.packTypes
         .set('resourcepack', new ResourcePack(options))
         .get('resourcepack') as ResourcePack
@@ -832,14 +834,14 @@ export class SandstonePack {
     initialize: INITIAL,
     dataPoint?: DataPointClass<'storage'>,
   ) {
-    return DataIndexMap(this, initialize, dataPoint) as DataIndexMap<INITIAL>
+    return DataIndexMapInternal(this, initialize, dataPoint) as DataIndexMapType<INITIAL>
   }
 
   DataArray<INITIAL extends readonly NBTObject[] | readonly [string, DataPointClass | DataPointPickClass]>(
     initialize: INITIAL,
     dataPoint?: DataPointClass<'storage'>,
   ) {
-    return DataArray(this, initialize, dataPoint) as DataArray<INITIAL>
+    return DataArrayInternal(this, initialize, dataPoint) as DataArrayType<INITIAL>
   }
 
   getTempStorage = (name: string) => {
@@ -1123,14 +1125,14 @@ export class SandstonePack {
       ...options,
     })
 
-  // DecoratedPotPattern = (name: string, decoratedPotPattern: NonNullable<SymbolResource['decorated_pot_pattern']>, options?: Partial<DecoratedPotPatternClassArguments>) =>
-  //   new DecoratedPotPatternClass(this.core, name, {
-  //     json: decoratedPotPattern,
-  //     creator: 'user',
-  //     addToSandstoneCore: true,
-  //     onConflict: conflictDefaults('decorated_pot_pattern') as DecoratedPotPatternClassArguments['onConflict'],
-  //     ...options,
-  //   })
+  DecoratedPotPattern = (name: string, decoratedPotPattern: DecoratedPotPatternClassArguments['json'], options?: Omit<Partial<DecoratedPotPatternClassArguments>, 'json'>) =>
+    new DecoratedPotPatternClass(this.core, name, {
+      json: decoratedPotPattern,
+      creator: 'user',
+      addToSandstoneCore: true,
+      onConflict: conflictDefaults('decorated_pot_pattern') as DecoratedPotPatternClassArguments['onConflict'],
+      ...options,
+    })
 
   ItemModifier = (name: string, itemModifier: ItemModifierClassArguments['json'], options?: Omit<Partial<ItemModifierClassArguments>, 'json'>) =>
     new ItemModifierClass(this.core, name, {
@@ -1172,14 +1174,14 @@ export class SandstonePack {
       ...options,
     })
 
-  // SlotSource = (name: string, slotSource: NonNullable<SymbolResource['slot_source']>, options?: Partial<SlotSourceClassArguments>) =>
-  //   new SlotSourceClass(this.core, name, {
-  //     json: slotSource,
-  //     creator: 'user',
-  //     addToSandstoneCore: true,
-  //     onConflict: conflictDefaults('slot_source') as SlotSourceClassArguments['onConflict'],
-  //     ...options,
-  //   })
+  SlotSource = (name: string, slotSource: SlotSourceClassArguments['json'], options?: Omit<Partial<SlotSourceClassArguments>, 'json'>) =>
+    new SlotSourceClass(this.core, name, {
+      json: slotSource,
+      creator: 'user',
+      addToSandstoneCore: true,
+      onConflict: conflictDefaults('slot_source') as SlotSourceClassArguments['onConflict'],
+      ...options,
+    })
 
   SulfurCubeArchetype = (name: string, sulfurCubeArchetype: SulfurCubeArchetypeClassArguments['json'], options?: Omit<Partial<SulfurCubeArchetypeClassArguments>, 'json'>) =>
     new SulfurCubeArchetypeClass(this.core, name, {
@@ -1366,16 +1368,16 @@ export class SandstonePack {
       ...options,
     })
 
-  BlockState<JSON extends BlockStateJSON>(
+  BlockStateDefinition<JSON extends BlockStateDefinitionJSON>(
     name: string,
     json: JSON,
-    options?: Omit<Partial<BlockStateArguments<JSON>>, 'json'>,
+    options?: Omit<Partial<BlockStateDefinitionArguments<JSON>>, 'json'>,
   ) {
-    return new BlockStateClass(this.core, name, {
+    return new BlockStateDefinitionClass(this.core, name, {
       json,
       creator: 'user',
       addToSandstoneCore: true,
-      onConflict: conflictDefaults('blockstate') as BlockStateArguments<JSON>['onConflict'],
+      onConflict: conflictDefaults('blockstate') as BlockStateDefinitionArguments<JSON>['onConflict'],
       ...options,
     })
   }