sandstone 1.0.0 → 1.0.2

package/src/arguments/jsonTextComponent.ts

@@ -1,265 +1,9 @@
-import type { LiteralUnion } from 'sandstone/utils'
-import type { ComponentClass } from 'sandstone/variables/abstractClasses'
-import type { VectorClass } from 'sandstone/variables/Coordinates'
-import type { BASIC_COLORS } from './basics'
-import type { MultipleEntitiesArgument } from './selector'
+import { Text, TextObject, TextStyle } from './generated/util/text'
 
-export type JSONContentTypes = 'text' | 'translatable' | 'score' | 'selector' | 'keybind' | 'nbt'
+export type JSONContentTypes = NonNullable<TextObject['type']>
 
-// To be valid, a chat component must contain one content tag: text, translate, score, selector, keybind, or nbt.
-export type ContentTag<Type extends JSONContentTypes> = (Type extends 'text'
-  ? {
-      type?: 'text'
-      /** A string containing plain text to display directly. Can also be a number or boolean that is displayed directly. */
-      text: string | number | boolean
-    }
-  : Type extends 'translatable'
-    ? {
-        /** A translation identifier, to be displayed as the corresponding text in the player's selected language. */
-        translate: string
+export type FormattingTags = TextStyle
 
-        /** Optional. Depreciated. A list of raw JSON text component arguments to be inserted into slots in the translation text.  */
-        with?: ContentTag<JSONContentTypes>[]
+export type JSONTextComponent = Text
 
-        /** Optional. A raw JSON text component that will be used in place of a translation if it is missing */
-        fallback?: ContentTag<JSONContentTypes>
-      }
-    : Type extends 'score'
-      ? {
-          type?: 'score'
-          /**
-           * Displays a score holder's current score in an objective.
-           *
-           * Displays nothing if the given score holder or the given objective do not exist,
-           * or if the score holder is not tracked in the objective.
-           */
-          score: {
-            /**
-             * The name of the score holder whose score should be displayed.
-             * This can be a selector like @p or an explicit name.
-             */
-            name: MultipleEntitiesArgument<false>
-
-            /** The internal name of the objective to display the player's score in. */
-            objective: string
-
-            /** Optional. If present, this value is used regardless of what the score would have been. */
-            value?: number
-          }
-        }
-      : Type extends 'selector'
-        ? {
-            type?: 'selector'
-            /**
-             * An entity selector. Displayed as the name of the player or entity found by the selector.
-             *
-             * If more than one player or entity is found by the selector,
-             * their names are displayed in either the form "Name1 and Name2" or the form "Name1, Name2, Name3, and Name4".
-             */
-            selector: string
-
-            /** Optional, defaults to {"color": "gray", "text": ", "}. Used as the separator between different names, if the component selects multiple entities. */
-            separator?: JSONTextPrimitives | ContentTag<JSONContentTypes>
-          }
-        : Type extends 'keybind'
-          ? {
-              type?: 'keybind'
-              /**
-               * A keybind identifier, to be displayed as the name of the button that is currently bound to a certain action.
-               * For example, {"keybind": "key.inventory"} will display "e" if the player is using the default control scheme.
-               */
-              keybind: string
-            }
-          : Type extends 'nbt'
-            ? {
-                type?: 'nbt'
-                /**
-                 * The NBT path used for looking up NBT values from an entity, a block entity or an NBT storage.
-                 *
-                 * NBT strings display their contents.
-                 * Other NBT values are displayed as SNBT with no spacing or linebreaks.
-                 *
-                 * How values are displayed depends on the value of `interpret`.
-                 */
-                nbt: string
-
-                /**
-                 * Optional.
-                 * If true, the game will try to parse the text of each NBT value as a raw JSON text component.
-                 *
-                 * This usually only works if the value is an NBT string containing JSON, since JSON and SNBT are not compatible.
-                 *
-                 * If parsing fails, displays nothing.
-                 *
-                 * @default false
-                 */
-                interpret?: boolean
-              } & NBTTarget
-            : never) &
-  ChildrenTags &
-  FormattingTags &
-  InteractivityTags
-
-type NBTTarget =
-  | {
-      /**
-       * The coordinates of the block entity from which the NBT value is obtained.
-       * The coordinates can be absolute or relative.
-       */
-      block: string | VectorClass<[string, string, string]>
-    }
-  | {
-      /** The target selector for the entity or entities from which the NBT value is obtained. */
-      entity: MultipleEntitiesArgument<false>
-    }
-  | {
-      /** The namespaced ID of the command storage from which the NBT value is obtained */
-      storage: string
-    }
-
-type ChildrenTags = {
-  /**
-   * Optional. A list of child raw JSON text components to be displayed after this one.
-   *
-   * Child text components inherit all formatting and interactivity from the parent component,
-   * unless they explicitly override them.
-   */
-  extra?: (JSONTextPrimitives | ContentTag<JSONContentTypes>)[]
-}
-
-export type FormattingTags = {
-  /** Optional. The color to render the content in. */
-  color?: LiteralUnion<BASIC_COLORS>
-
-  /**
-   * Optional.
-   * The resource location of the font for this component in the resource pack within assets/<namespace>/font.
-   *
-   * @default "minecraft:default"
-   */
-  font?: string
-
-  /** Optional. Whether to render the content in bold. */
-  bold?: boolean
-
-  /**
-   * Optional. Whether to render the content in italics.
-   *
-   * Note that text which is italicized by default, such as custom item names,
-   * can be unitalicized by setting this to false.
-   */
-  italic?: boolean
-
-  /** Optional. Whether to underline the content. */
-  underlined?: boolean
-
-  /** Optional. Whether to strikethrough the content. */
-  strikethrough?: boolean
-
-  /** Optional. Whether to render the content obfuscated. */
-  obfuscated?: boolean
-}
-
-type InteractivityTags = {
-  /**
-   * Optional. When the text is shift-clicked by a player, this string is inserted in their chat input.
-   * It does not overwrite any existing text the player was writing. This only works in chat messages.
-   */
-  insertion?: string | number | boolean
-
-  /**
-   * Optional. Allows for events to occur when the player clicks on text.
-   * Only work in chat messages and written books, unless specified otherwise.
-   */
-  clickEvent?: {
-    /**
-     * The action to perform when clicked.
-     *
-     * Valid values are:
-     * - `open_url`: Opens `value` as a URL in the user's default web browser.
-     *
-     * - `open_file`: Opens the file at `value` on the user's computer. This is used in messages automatically generated
-     * by the game (e.g., on taking a screenshot) and cannot be used by players for security reasons.
-     *
-     * - `run_command`: Works in signs, but only on the root text component, not on any children. Activated by using the sign.
-     * In chat and written books, this has `value` entered in chat as though the player typed it themselves and pressed enter.
-     * This can be used to run commands, provided the player has the required permissions. Since they are being run from chat,
-     * commands must be prefixed with the usual `/` slash. In signs, the command is run by the server at the sign's location,
-     * with the player who used the sign as @s. Since they are run by the server, sign commands have the same permission level as a command block,
-     * instead of using the player's permission level, are not restricted by chat length limits, and do not need to be prefixed with a `/` slash.
-     *
-     * - `suggest_command`: Opens chat and fills in `value`. If a chat message was already being composed, it is overwritten.
-     *
-     * - `change_page`: Can only be used in written books. Changes to page `value` if that page exists.
-     *
-     * - `copy_to_clipboard`: Copies `value` to the clipboard.
-     */
-    action: 'open_url' | 'open_file' | 'run_command' | 'suggest_command' | 'change_page' | 'copy_to_clipboard'
-
-    /** The URL, file path, chat, command or book page used by the specified action. */
-    value: string
-  }
-
-  /** Optional. Allows for a tooltip to be displayed when the player hovers their mouse over text. */
-  hoverEvent?:
-    | {
-        /**
-         * The type of tooltip to show.
-         *
-         * Valid values are:
-         * - `show_text `: Shows a raw JSON text component.
-         * - `show_item `: Shows the tooltip of an item as if it was being hovering over it in an inventory.
-         * - `show_entity `: Shows an entity's name, type, and UUID. Used by `selector`.
-         */
-        action: 'show_text'
-
-        /**
-         * The formatting of this tag varies depending on the action.
-         *
-         * `show_text`: Another raw JSON text component. Can be any valid text component type: string, array, or object.
-         * Note that clickEvent and hoverEvent do not function within the tooltip.
-         * `show_item`: The item that should be displayed.
-         * `show_entity`: The entity that should be displayed.
-         */
-        contents: JSONTextPrimitives | ContentTag<JSONContentTypes>
-      }
-    | {
-        action: 'show_item'
-
-        /** The item that should be displayed. */
-        contents: {
-          /** The namespaced item ID. Present `minecraft:air` if invalid. */
-          id: string
-
-          /** Optional. Size of the item stack. */
-          count?: number
-
-          /** Optional. A string containing the serialized NBT of the additional information about the item. */
-          tag?: string
-        }
-      }
-    | {
-        action: 'show_entity'
-
-        /** The entity that should be displayed */
-        contents: {
-          /** Optional. Hidden if not present. A raw JSON text that is displayed as the name of the entity. */
-          name?: string
-
-          /** A string containing the type of the entity. Should be a namespaced entity ID. Present `minecraft:pig` if invalid. */
-          type: string
-
-          /** A string containing the UUID of the entity in the hyphenated hexadecimal format. Should be a valid UUID. */
-          id: string
-        }
-      }
-}
-
-export type JSONTextPrimitives = string | boolean | number | ComponentClass
-
-/*
- * A JSON text component, that can be displayed in several locations: in-game chat, books, signs, titles...
- *
- * Warning: Empty lists are not supported by the game, but typing this way is restrictive.
- */
-export type JSONTextComponent = JSONTextPrimitives | ContentTag<JSONContentTypes> | JSONTextComponent[]
+export type { TextObject }

package/src/arguments/nbt.ts

@@ -1,9 +1,34 @@
-import type { NBTClass } from 'sandstone/variables/nbt/NBTs'
+import type { TextObject } from './generated/util/text'
+import { TextComponentClass } from 'sandstone/variables'
+import type {
+  NBTByte,
+  NBTByteArray,
+  NBTClass,
+  NBTDouble,
+  NBTFloat,
+  NBTInt,
+  NBTIntArray,
+  NBTLong,
+  NBTLongArray,
+  NBTShort,
+} from 'sandstone/variables/nbt/NBTs'
 
 export interface NBTSerializable {
   toNBT(): string
 }
 
-export type NBTObject = string | number | boolean | URL | undefined | NBTSerializable | { [key: string]: NBTObject | undefined } | NBTObject[] | NBTClass
+export type NBTObject = string | number | boolean | URL | undefined | NBTSerializable | TextComponentClass | TextObject | { [key: string]: NBTObject | undefined } | NBTObject[] | NBTClass
 
-export type RootNBT = Record<string, NBTObject | undefined>
+export type RootNBT = Record<`${any}${string}`, NBTObject | undefined>
+
+/**
+ * Recursively walks a type, unioning Sandstone NBT primitive classes with their plain JSON equivalents
+ */
+export type MCDocToJSON<T> =
+  T extends NBTInt | NBTFloat | NBTDouble | NBTByte | NBTShort | NBTLong ? (number | T) :
+  T extends NBTIntArray | NBTLongArray | NBTByteArray ? (number | T)[] :
+  T extends (...args: any[]) => any ? T :
+  T extends NBTSerializable | TextComponentClass ? T :
+  T extends ReadonlyArray<infer U> ? Array<MCDocToJSON<U>> :
+  T extends object ? { [K in keyof T]: MCDocToJSON<T[K]> } :
+  T

package/src/commands/implementations/block/fill.ts

@@ -1,10 +1,11 @@
-import type { Coordinates, NBTObject, SymbolBlock, SymbolMcdocBlockStates } from 'sandstone/arguments'
+import type { Coordinates, RootNBT, SymbolBlock, SymbolMcdocBlockStates } from 'sandstone/arguments'
 import type { Macroable, TagClass } from 'sandstone/core'
 import { CommandNode } from 'sandstone/core/nodes'
 import { coordinatesParser, nbtResolver } from 'sandstone/variables'
 import { CommandArguments, type FinalCommandOutput } from '../../helpers'
 import type { Registry } from 'sandstone/arguments/generated/registry'
 import { blockStateStringifier, type BlockEntity, type BlockStatic, type ParseBlockState } from './setblock'
+import type { AllowConst } from 'sandstone/utils'
 
 export class FillCommandNode extends CommandNode {
   command = 'fill' as const
@@ -71,7 +72,10 @@ export class FillCommand<MACRO extends boolean> extends CommandArguments {
     to: Macroable<Coordinates<MACRO>, MACRO>,
     block: BLOCK,
     state?: Macroable<BLOCK extends keyof SymbolMcdocBlockStates ? ParseBlockState<NonNullable<SymbolMcdocBlockStates[BLOCK]>> : Record<string, string | boolean | number>, MACRO>,
-    nbt?: Macroable<BLOCK extends keyof SymbolBlock ? NonNullable<SymbolBlock[BLOCK]> : SymbolBlock<'%fallback'>, MACRO>,
+    nbt?: Macroable<BLOCK extends keyof SymbolBlock
+      ? NonNullable<AllowConst<SymbolBlock[Extract<BLOCK, keyof SymbolBlock>]>>
+      : AllowConst<RootNBT>,
+    MACRO>,
   ): FillArgumentsCommand<MACRO>
 
   fill(
@@ -79,7 +83,7 @@ export class FillCommand<MACRO extends boolean> extends CommandArguments {
     to: Macroable<Coordinates<MACRO>, MACRO>,
     block: Macroable<Registry['minecraft:block'], MACRO>,
     state?: Record<string, string | boolean | number>,
-    nbt?: NBTObject,
+    nbt?: AllowConst<RootNBT>,
   ): FillArgumentsCommand<MACRO> {
     const stateStr = state && Object.keys(state).length > 0 ? blockStateStringifier(state) : ''
     const nbtStr = nbt ? nbtResolver(nbt).toString() : ''

package/src/commands/implementations/block/place.ts

@@ -26,7 +26,7 @@ export class PlaceCommand<MACRO extends boolean> extends CommandArguments {
    * @param pos Optional. Where the placement should be tried.
    */
   feature = (
-    feature: Macroable<Registry['minecraft:worldgen/configured_feature'], MACRO>,
+    feature: Macroable<Registry['minecraft:worldgen/feature'], MACRO>,
     pos: Macroable<Coordinates<MACRO>, MACRO> = '~ ~ ~' as Coordinates<MACRO>,
   ) => this.finalCommand(['feature', feature, coordinatesParser(pos)])
 

package/src/commands/implementations/block/setblock.ts

@@ -1,11 +1,11 @@
-import type { Coordinates, NBTObject, SymbolBlock, SymbolMcdocBlockStates } from 'sandstone/arguments'
+import type { Coordinates, RootNBT, SymbolBlock, SymbolMcdocBlockStates } from 'sandstone/arguments'
 import type { Macroable } from 'sandstone/core'
 import { CommandNode } from 'sandstone/core/nodes'
 import { coordinatesParser, nbtResolver } from 'sandstone/variables'
 import type { FinalCommandOutput } from '../../helpers'
 import { CommandArguments } from '../../helpers'
 import type { Registry } from 'sandstone/arguments/generated/registry'
-import type { NamespacedLiteralUnion } from 'sandstone/utils'
+import type { AllowConst, NamespacedLiteralUnion } from 'sandstone/utils'
 
 /** Converts stringified boolean/numeric literals to actual booleans/numbers */
 export type ParseLiteral<T> = (
@@ -21,7 +21,7 @@ export type ParseBlockState<T> = {
 
 export type BlockEntity = NamespacedLiteralUnion<keyof SymbolBlock>
 
-export type BlockStatic = NamespacedLiteralUnion<Exclude<keyof SymbolMcdocBlockStates, keyof SymbolBlock>>
+export type BlockStatic = NamespacedLiteralUnion<Exclude<keyof SymbolMcdocBlockStates, keyof SymbolBlock>> | 'air' | 'minecraft:air'
 
 export class SetBlockCommandNode extends CommandNode {
   command = 'setblock' as const
@@ -37,24 +37,24 @@ export class SetBlockCommand<MACRO extends boolean> extends CommandArguments {
    * This is the basic form for simple block placement without NBT data.
    *
    * @param pos The coordinates where to place the block. Supports:
-   *           - Absolute: `abs(100, 64, 200)` - exact world coordinates
-   *           - Relative: `['~5', '~1', '~-3']` - relative to command position
-   *           - Local: `['^2', '^', '^-1']` - relative to facing direction
-   *           - Mixed: `[100, '~5', '^2']` - combination of systems
+   *             - Absolute: `abs(100, 64, 200)` - exact world coordinates
+   *             - Relative: `['~5', '~1', '~-3']` - relative to command position
+   *             - Local: `['^2', '^', '^-1']` - relative to facing direction
+   *             - Mixed: `[100, '~5', '^2']` - combination of systems
    *
    * @param block The block type to place (e.g., `'minecraft:stone'`, `'oak_log'`).
    *
    * @param state Optional block state properties as an object. The available
-   *             properties are type-checked based on the block type:
-   *             - Oak log: `{ axis: 'x' | 'y' | 'z' }`
-   *             - Redstone wire: `{ power: 0-15, north: 'none' | 'side' | 'up', ... }`
-   *             - Stairs: `{ facing: 'north' | 'south' | 'east' | 'west', half: 'top' | 'bottom', ... }`
+   *              properties are type-checked based on the block type:
+   *               - Oak log: `{ axis: 'x' | 'y' | 'z' }`
+   *               - Redstone wire: `{ power: 0-15, north: 'none' | 'side' | 'up', ... }`
+   *               - Stairs: `{ facing: 'north' | 'south' | 'east' | 'west', half: 'top' | 'bottom', ... }`
    *
-   * @param type How to handle the placement. Options:
-   *            - `'replace'` (default): Silently replace any existing block
-   *            - `'destroy'`: Break existing block, dropping items and playing sound
-   *            - `'keep'`: Only place if the target location is air
-   *            - `'strict'`: Replace without issuing block updates
+   * @param flag How to handle the placement. Options:
+   *              - `'replace'` (default): Silently replace any existing block
+   *              - `'destroy'`: Break existing block, dropping items and playing sound
+   *              - `'keep'`: Only place if the target location is air
+   *              - `'strict'`: Replace without issuing block updates
    *
    * @example
    * ```ts
@@ -82,7 +82,7 @@ export class SetBlockCommand<MACRO extends boolean> extends CommandArguments {
     pos: Macroable<Coordinates<MACRO>, MACRO>,
     block: BLOCK,
     state?: Macroable<BLOCK extends keyof SymbolMcdocBlockStates ? ParseBlockState<NonNullable<SymbolMcdocBlockStates[Extract<BLOCK, keyof SymbolMcdocBlockStates>]>> : Record<string, string | boolean | number>, MACRO>,
-    type?: 'destroy' | 'keep' | 'replace' | 'strict',
+    flag?: 'destroy' | 'keep' | 'replace' | 'strict',
   ): FinalCommandOutput
 
   /**
@@ -95,23 +95,27 @@ export class SetBlockCommand<MACRO extends boolean> extends CommandArguments {
    * @param pos The coordinates where to place the block. Same format as basic variant.
    *
    * @param block The block type to place. Must be a block that supports NBT data:
-   *             - `'minecraft:chest'` - for containers
-   *             - `'minecraft:command_block'` - for command storage
-   *             - `'minecraft:sign'` - for text display
-   *             - `'minecraft:spawner'` - for mob spawning
+   *               - `'minecraft:chest'` - for containers
+   *               - `'minecraft:command_block'` - for command storage
+   *               - `'minecraft:sign'` - for text display
+   *               - `'minecraft:spawner'` - for mob spawning
    *
    * @param state Optional block state properties as an object. Type-checked based on block:
-   *             - Chest: `{ facing: 'north' | 'south' | 'east' | 'west', type: 'single' | 'left' | 'right', ... }`
-   *             - Command block: `{ facing: 'north' | 'south' | 'east' | 'west' | 'up' | 'down', conditional: true | false }`
-   *             - Sign: `{ rotation: 0-15 }` or `{ facing: ... }` for wall signs
+   *               - Chest: `{ facing: 'north' | 'south' | 'east' | 'west', type: 'single' | 'left' | 'right', ... }`
+   *               - Command block: `{ facing: 'north' | 'south' | 'east' | 'west' | 'up' | 'down', conditional: true | false }`
+   *               - Sign: `{ rotation: 0-15 }` or `{ facing: ... }` for wall signs
    *
    * @param nbt The NBT data object defining the block's properties:
-   *           - For chests: `{ Items: [{ Slot: 0, id: 'diamond', Count: 1 }] }`
-   *           - For signs: `{ front_text: { messages: [...] } }`
-   *           - For command blocks: `{ Command: 'say Hello' }`
-   *           - For spawners: `{ SpawnData: { id: 'minecraft:zombie' } }`
+   *             - For chests: `{ Items: [{ Slot: 0, id: 'diamond', Count: 1 }] }`
+   *             - For signs: `{ front_text: { messages: [...] } }`
+   *             - For command blocks: `{ Command: 'say Hello' }`
+   *             - For spawners: `{ SpawnData: { id: 'minecraft:zombie' } }`
    *
-   * @param type Placement behavior, same as basic variant.
+   * @param flag How to handle the placement. Options:
+   *              - `'replace'` (default): Silently replace any existing block
+   *              - `'destroy'`: Break existing block, dropping items and playing sound
+   *              - `'keep'`: Only place if the target location is air
+   *              - `'strict'`: Replace without issuing block updates
    *
    * @example
    * ```ts
@@ -139,8 +143,11 @@ export class SetBlockCommand<MACRO extends boolean> extends CommandArguments {
     pos: Macroable<Coordinates<MACRO>, MACRO>,
     block: BLOCK,
     state?: Macroable<BLOCK extends keyof SymbolMcdocBlockStates ? ParseBlockState<NonNullable<SymbolMcdocBlockStates[Extract<BLOCK, keyof SymbolMcdocBlockStates>]>> : Record<string, string | boolean | number>, MACRO>,
-    nbt?: Macroable<BLOCK extends keyof SymbolBlock ? NonNullable<SymbolBlock[Extract<BLOCK, keyof SymbolBlock>]> : SymbolBlock<'%fallback'>, MACRO>,
-    type?: 'destroy' | 'keep' | 'replace' | 'strict',
+    nbt?: Macroable<BLOCK extends keyof SymbolBlock
+      ? NonNullable<AllowConst<SymbolBlock[Extract<BLOCK, keyof SymbolBlock>]>>
+      : AllowConst<RootNBT>,
+    MACRO>,
+    flag?: 'destroy' | 'keep' | 'replace' | 'strict',
   ): FinalCommandOutput
 
   setblock(
@@ -158,7 +165,7 @@ export class SetBlockCommand<MACRO extends boolean> extends CommandArguments {
       : blockStateStringifier(arg3 as any as Record<string, string | number | boolean>)
     const nbt = typeof arg4 === 'string' || arg4 === undefined ?
       ''
-      : nbtResolver(arg4 as any as NBTObject).toString()
+      : nbtResolver(arg4 as any as RootNBT).toString()
     const setblockType = typeof arg4 === 'string' ? arg4 : arg5
 
     return this.finalCommand([coordinatesParser(pos), `${block}${state}${nbt}`, setblockType])
@@ -168,7 +175,7 @@ export class SetBlockCommand<MACRO extends boolean> extends CommandArguments {
 export function blockStateStringifier(state: Record<string, string | number | boolean>) {
   let resultPairs: string[] = []
 
-  for (const [key, value] of Object.entries(Object.entries(state))) {
+  for (const [key, value] of Object.entries(state)) {
     resultPairs.push(`${key}=${value}`)
   }
   return `[${resultPairs.join(',')}]`

package/src/commands/implementations/entity/execute.ts

@@ -14,6 +14,7 @@ import type {
   SingleEntityArgumentOf,
   SymbolBlock,
   SymbolMcdocBlockStates,
+  RootNBT,
 } from 'sandstone/arguments'
 import { blockStateStringifier } from '../block/setblock'
 import type { SandstoneCommands } from 'sandstone/commands'
@@ -28,7 +29,7 @@ import type { Node } from 'sandstone/core/nodes'
 import { ContainerCommandNode } from 'sandstone/core/nodes'
 import type { _RawMCFunctionClass } from 'sandstone/core/resources/datapack/mcfunction'
 import type { SandstonePack } from 'sandstone/pack'
-import { makeCallable, type NamespacedLiteralUnion } from 'sandstone/utils'
+import { type AllowConst, makeCallable, type NamespacedLiteralUnion } from 'sandstone/utils'
 import type { DataPointClass } from 'sandstone/variables/Data'
 import type { ObjectiveClass } from 'sandstone/variables/Objective'
 import type { ItemPredicateClass } from 'sandstone/variables/ItemPredicate'
@@ -62,6 +63,8 @@ const isObjective = (arg: any): arg is ObjectiveClass => typeof arg === 'object'
 const isScore = (arg: any): arg is Score => typeof arg === 'object' && Object.hasOwn(arg, 'setDisplay')
 
 export class ExecuteCommandPart<MACRO extends boolean> extends CommandArguments<typeof ExecuteCommandNode> {
+  protected NodeType = ExecuteCommandNode
+
   /**
    * @internal
    */
@@ -559,15 +562,16 @@ export class ExecuteIfUnlessCommand<MACRO extends boolean> extends ExecuteComman
       ? ParseBlockState<NonNullable<SymbolMcdocBlockStates[Extract<BLOCK, keyof SymbolMcdocBlockStates>]>>
       : Record<string, string | boolean | number> | undefined, MACRO>,
     nbt: Macroable<BLOCK extends keyof SymbolBlock
-      ? NonNullable<SymbolBlock[Extract<BLOCK, keyof SymbolBlock>]>
-      : SymbolBlock<'%fallback'>, MACRO>,
+      ? NonNullable<AllowConst<SymbolBlock[Extract<BLOCK, keyof SymbolBlock>]>>
+      : AllowConst<RootNBT>,
+    MACRO>,
   ): ExecuteCommand<MACRO>
 
   block(
     pos: Macroable<Coordinates<MACRO>, MACRO>,
     block: Macroable<Registry['minecraft:block'], MACRO>,
     state?: Macroable<Record<string, string | boolean | number>, MACRO>,
-    nbt?: Macroable<NBTObject, MACRO>,
+    nbt?: Macroable<AllowConst<RootNBT>, MACRO>,
   ) {
     const stateStr = state && typeof state === 'object' && Object.keys(state).length > 0
       ? blockStateStringifier(state as Record<string, string | number | boolean>)

package/src/commands/implementations/entity/summon.ts

@@ -1,10 +1,11 @@
 import type { Coordinates, RootNBT, SymbolEntity } from 'sandstone/arguments'
 import type { Macroable } from 'sandstone/core'
 import { CommandNode } from 'sandstone/core/nodes'
-import { nbtResolver } from 'sandstone/variables/nbt/NBTs'
+import { NBT, nbtResolver } from 'sandstone/variables/nbt/NBTs'
 import { coordinatesParser } from 'sandstone/variables/parsers'
 import { CommandArguments } from '../../helpers'
 import type { Registry } from 'sandstone/arguments/generated/registry'
+import { AllowConst } from 'sandstone/utils'
 
 export class SummonCommandNode extends CommandNode {
   command = 'summon' as const
@@ -18,14 +19,6 @@ export class SummonCommand<MACRO extends boolean> extends CommandArguments {
    * 
    * Creates a new entity in the world with optional positioning and NBT data.
    * The entity will be created with default properties unless overridden by NBT.
-   * 
-   * **Entity Categories:**
-   * - **Mobs:** 'minecraft:zombie', 'minecraft:villager', 'minecraft:cow'
-   * - **Items:** 'minecraft:item' (requires Item NBT)
-   * - **Projectiles:** 'minecraft:arrow', 'minecraft:fireball'
-   * - **Vehicles:** 'minecraft:boat', 'minecraft:minecart'
-   * - **Utility:** 'minecraft:armor_stand', 'minecraft:item_frame'
-   * - **Effects:** 'minecraft:area_effect_cloud', 'minecraft:marker'
    *
    * @param entity The entity type to summon. Must be a valid entity ID.
    *              Examples: 'minecraft:zombie', 'minecraft:cow', 'minecraft:armor_stand'
@@ -58,7 +51,7 @@ export class SummonCommand<MACRO extends boolean> extends CommandArguments {
   summon<ENTITY extends Macroable<Registry['minecraft:entity_type'], MACRO>>(
     entity: ENTITY,
     pos?: Macroable<Coordinates<MACRO>, MACRO>,
-    nbt?: Macroable<ENTITY extends keyof SymbolEntity ? NonNullable<SymbolEntity[ENTITY]> : RootNBT, MACRO>,
+    nbt?: Macroable<AllowConst<ENTITY extends keyof SymbolEntity ? NonNullable<SymbolEntity[ENTITY]> : RootNBT>, MACRO>,
   ) {
     const args: unknown[] = [entity]
     if (pos !== undefined) {

package/src/commands/implementations/entity/team.ts

@@ -1,4 +1,4 @@
-import type { BASIC_COLORS, JSONTextComponent, MultipleEntitiesArgument } from 'sandstone/arguments'
+import type { JSONTextComponent, MultipleEntitiesArgument, TextColor } from 'sandstone/arguments'
 import type { Macroable } from 'sandstone/core'
 import { CommandNode } from 'sandstone/core/nodes'
 import { parseJSONText } from 'sandstone/variables/JSONTextComponentClass'
@@ -7,7 +7,7 @@ import { CommandArguments } from '../../helpers'
 
 interface TeamOptions {
   collisionRule: 'always' | 'never' | 'pushOtherTeams' | 'pushOwnTeam'
-  color: BASIC_COLORS
+  color: TextColor
   deathMessageVisibility: 'never' | 'hideForOtherTeams' | 'hideForOwnTeam' | 'always'
   friendlyFire: boolean
   nametagVisibility: 'never' | 'hideForOtherTeams' | 'hideForOwnTeam' | 'always'

package/src/commands/implementations/index.ts

@@ -5,7 +5,7 @@ export * from './block/fill'
 export * from './block/place'
 export * from './block/setblock'
 export * from './entity/attribute'
-export * from './entity/clear'
+export * from './player/clear'
 export * from './entity/damage'
 export * from './entity/effect'
 export * from './entity/enchant'

package/src/commands/implementations/player/bossbar.ts

@@ -1,4 +1,4 @@
-import type { BASIC_COLORS, JSONTextComponent, MultiplePlayersArgumentOf } from 'sandstone/arguments'
+import type { JSONTextComponent, MultiplePlayersArgumentOf, TextColor } from 'sandstone/arguments'
 import type { Macroable } from 'sandstone/core'
 import { CommandNode } from 'sandstone/core/nodes'
 import type { LiteralUnion } from 'sandstone/utils'
@@ -91,7 +91,7 @@ export class BossBarSetCommand<MACRO extends boolean> extends CommandArguments {
    *
    * @param color The new color.
    */
-  color = (color: Macroable<LiteralUnion<BASIC_COLORS>, MACRO>) => this.finalCommand(['color', color])
+  color = (color: Macroable<LiteralUnion<TextColor>, MACRO>) => this.finalCommand(['color', color])
 
   /**
    * Set the boss bar's maximum value.

package/src/commands/implementations/player/dialog.ts

@@ -1,4 +1,4 @@
-import type { MultiplePlayersArgument } from 'sandstone/arguments'
+import type { MCDocToJSON, MultiplePlayersArgument } from 'sandstone/arguments'
 import type { Dialog } from 'sandstone/arguments/generated/data/dialog'
 import type { DIALOGS } from 'sandstone/arguments/generated/_registry/dialogs'
 import type { DialogClass, Macroable } from 'sandstone/core'
@@ -27,11 +27,11 @@ export class DialogCommand<MACRO extends boolean> extends CommandArguments {
    */
   show(
     targets: Macroable<MultiplePlayersArgument<MACRO>, MACRO>,
-    dialog: Macroable<DIALOGS | DialogClass | Dialog, MACRO>,
+    dialog: Macroable<DIALOGS | DialogClass | MCDocToJSON<Dialog>, MACRO>,
   ): FinalCommandOutput {
     const dialogArg = typeof dialog === 'string' || dialog instanceof ResourceClass
       ? dialog
-      : nbtResolver(dialog as Dialog)
+      : nbtResolver(dialog as any)
     return this.finalCommand(['show', targetParser(targets), dialogArg])
   }