sandstone 1.0.0 → 1.0.1

package/src/sandstone.ts

@@ -1,6 +1,6 @@
 import type { JSONTextComponent } from './arguments/jsonTextComponent'
 import type { SandstoneContext } from './context'
-import type { FillCommand, SetBlockCommand } from './commands'
+import type { FillCommand, GiveCommand, SetBlockCommand } from './commands'
 import type {
   AdvancementClassArguments,
   AtlasClassArguments,
@@ -28,6 +28,7 @@ import type {
   RecipeClassArguments,
   ShaderClassArguments,
   SoundEventArguments,
+  SoundsIndexArguments,
   TagClassArguments,
   TestEnvironmentClassArguments,
   TestInstanceClassArguments,
@@ -104,8 +105,8 @@ export { ResolveNBTPart }
 
 // Commands must go through sandstonePack.commands at call time for the same reason as pack methods.
 type SandstoneCommands = SandstonePack['commands']
-// Exclude setblock since it needs explicit type annotation due to complex generics
-type CommandKeys = Exclude<keyof SandstoneCommands, 'setblock' | 'fill'>
+// Exclude a few commands that need explicit type annotation due to complex generics
+type CommandKeys = Exclude<keyof SandstoneCommands, 'give' | 'setblock' | 'fill'>
 
 // Creates a proxy that handles both callable commands and object-based commands.
 // This avoids hardcoding which commands are object-based by detecting at runtime.
@@ -161,7 +162,6 @@ export const {
   forceload,
   gamemode,
   gamerule,
-  give,
   help,
   kill,
   list,
@@ -216,6 +216,10 @@ export const {
   tell,
 } = commandsProxy
 
+// give needs explicit type annotation due to complex generics
+export const give: GiveCommand<false>['give'] = ((...args: unknown[]) =>
+  (sandstonePack.commands.give as CallableFunction)(...args)) as GiveCommand<false>['give']
+
 // setblock needs explicit type annotation due to complex generics
 export const setblock: SetBlockCommand<false>['setblock'] = ((...args: unknown[]) =>
   (sandstonePack.commands.setblock as CallableFunction)(...args)) as SetBlockCommand<false>['setblock']
@@ -320,6 +324,7 @@ export const {
   PostEffect,
   Shader,
   SoundEvent,
+  SoundsIndex,
   PlainText,
   Texture,
   WaypointStyle,
@@ -402,6 +407,7 @@ export {
   ParticleClass,
   PostEffectClass,
   SoundEventClass,
+  SoundsIndexClass,
   TextureClass,
   WaypointStyleClass,
 } from './core/resources'
@@ -507,6 +513,8 @@ type PackConfigs<PackType extends LiteralUnion<'datapack' | 'resourcepack'>> = R
   PackType extends 'datapack' ? DatapackConfig : PackType extends 'resourcepack' ? ResourcePackConfig : unknown
 >
 
+export type HandlerFile = string | ArrayBuffer | Buffer
+
 export interface SandstoneConfig {
   /**
    * The default namespace for the packs.
@@ -607,7 +615,7 @@ export interface SandstoneConfig {
     handle?: {
       path: RegExp
 
-      callback: (contents: string | Buffer | Promise<Buffer>) => Promise<Buffer>
+      callback: (contents: HandlerFile | Promise<HandlerFile>) => HandlerFile | Promise<HandlerFile>
     }[]
   }
 }

package/src/utils.ts

@@ -4,23 +4,12 @@
 import type { Static } from '@sinclair/typebox'
 import { FormatRegistry, Type } from '@sinclair/typebox'
 import fs from 'fs-extra'
-import type FetchType from 'node-fetch'
-import type { Response } from 'node-fetch'
 import { coerce } from 'semver'
 import * as util from 'util'
 import type { MultipleEntitiesArgument } from './arguments/selector'
 import type { Node } from './core/nodes'
 import type { UUIDinNumber } from './variables/UUID'
 
-/* @ts-ignore */
-export const fetch: (input: URL | RequestInfo, init?: RequestInit | undefined) => Promise<Response> = Object.hasOwn(
-  globalThis,
-  'fetch',
-)
-  ? globalThis.fetch
-  : async (...args: Parameters<typeof FetchType>) =>
-    (await import('node-fetch')).default(...args) as unknown as Promise<Response>
-
 /**
  * Allows to get autocompletion on string unions, while still allowing generic strings.
  * @see https://github.com/microsoft/TypeScript/issues/29729#issuecomment-700527227
@@ -125,6 +114,7 @@ export type WithMCNamespace<T extends string> = `minecraft:${T}` | T
 
 export function makeCallableProxy(func: any, object: any) {
   return new Proxy(func, {
+    apply: (_t, _thisArg, args) => Reflect.apply(func, object, args),
     get: (_t, p, _r) => object[p],
     set: (_t, p, value, _r) => {
       object[p] = value
@@ -731,4 +721,6 @@ export type SmartRange<Min extends number, Max extends number> = (
       : ToNegative<PositiveRange<1, Abs<Min>>> | 0 | PositiveRange<1, Max>
     :
       PositiveRange<Min, Max>
-)
+)
+
+export type AllowConst<T> = T | (readonly [T])[0]

package/src/variables/Coordinates.ts

@@ -22,7 +22,7 @@ export class VectorClass<T extends readonly unknown[]> implements NBTSerializabl
   }
 
   toNBT() {
-    return this.toString()
+    return `'${this.toString()}'`
   }
 
   [Symbol.iterator](): Iterator<T[0]> {
@@ -48,7 +48,7 @@ type MappedArray<T, U> = { [key in keyof T]: U }
  * @see {@link relative} for relative coordinates (e.g. `~10`)
  * @see {@link local} for local coordinates (e.g. `^10`)
  */
-export function absolute(coordinate?: number): string
+export function absolute<T extends number>(coordinate?: T): `${T}`
 
 /**
  * Transforms numbers into absolute coordinates.
@@ -65,14 +65,14 @@ export function absolute(coordinate?: number): string
  * @see {@link relative} for relative coordinates (e.g. `~10`)
  * @see {@link local} for local coordinates (e.g. `^10`)
  */
-export function absolute<T extends Tuple<number>>(...coordinates: T): VectorClass<MappedArray<T, string>>
+export function absolute<T extends Tuple<number>>(...coordinates: T): VectorClass<MappedArray<T, `${number}`>>
 
-export function absolute<T extends Tuple<number>>(...coordinates: T): string | VectorClass<MappedArray<T, string>> {
+export function absolute<T extends Tuple<number>>(...coordinates: T): `${T[0]}`| VectorClass<MappedArray<T, `${number}`>> {
   if (coordinates.length === 1) {
-    return coordinates[0].toString()
+    return coordinates[0].toString() as `${T[0]}`
   }
 
-  return new VectorClass(coordinates.map((coord) => coord.toString()) as unknown as MappedArray<T, string>)
+  return new VectorClass(coordinates.map((coord) => coord.toString()) as unknown as MappedArray<T, `${number}`>)
 }
 
 /**
@@ -109,7 +109,7 @@ export function relative<T extends [0, 0, 0]>(): VectorClass<MappedArray<T, '~'>
  * @see {@link absolute} for absolute coordinates (e.g. `10`)
  * @see {@link local} for local coordinates (e.g. `^10`)
  */
-export function relative(coordinate: number): `~${string}`
+export function relative<T extends number>(coordinate: T): `~${T}`
 
 /**
  * Transforms numbers into relative coordinates, using the tilde notation `~`.
@@ -128,18 +128,18 @@ export function relative(coordinate: number): `~${string}`
  * @see {@link absolute} for absolute coordinates (e.g. `10`)
  * @see {@link local} for local coordinates (e.g. `^10`)
  */
-export function relative<T extends Tuple<number>>(...coordinates: T): VectorClass<MappedArray<T, `~${string}`>>
+export function relative<T extends Tuple<number>>(...coordinates: T): VectorClass<MappedArray<T, `~${number | ''}`>>
 
-export function relative<T extends Tuple<number>>(...coordinates: T): string | VectorClass<MappedArray<T, string>> {
+export function relative<T extends Tuple<number>>(...coordinates: T): '~' | `~${T[0]}`| VectorClass<MappedArray<T, `~${number | ''}`>> {
   if (coordinates.length === 0) {
-    return new VectorClass(['~', '~', '~'] as unknown as MappedArray<T, string>)
+    return new VectorClass(['~', '~', '~'] as unknown as MappedArray<T, `~${number | ''}`>)
   }
 
   if (coordinates.length === 1) {
-    return `~${coordinates[0] || ''}`
+    return `~${coordinates[0]}` as `~${T[0]}`
   }
 
-  return new VectorClass(coordinates.map((coord) => `~${coord || ''}`) as unknown as MappedArray<T, string>)
+  return new VectorClass(coordinates.map((coord) => `~${coord || ''}`) as unknown as MappedArray<T, `~${number | ''}`>)
 }
 
 /**
@@ -178,7 +178,7 @@ export function local<T extends [0, 0, 0]>(): VectorClass<MappedArray<T, '^'>>
  * @see {@link absolute} for absolute coordinates (e.g. `10`)
  * @see {@link relative} for relative coordinates (e.g. `~10`)
  */
-export function local(coordinate: number): `^${string}`
+export function local<T extends number>(coordinate: T): `^${T}`
 
 /**
  * Transforms numbers into local coordinates, using the tilde notation `^`.
@@ -199,16 +199,16 @@ export function local(coordinate: number): `^${string}`
  * @see {@link absolute} for absolute coordinates (e.g. `10`)
  * @see {@link relative} for relative coordinates (e.g. `~10`)
  */
-export function local<T extends Tuple<number>>(...coordinates: T): VectorClass<MappedArray<T, `^${string}`>>
+export function local<T extends Tuple<number>>(...coordinates: T): VectorClass<MappedArray<T, `^${number | ''}`>>
 
-export function local<T extends Tuple<number>>(...coordinates: T): string | VectorClass<MappedArray<T, string>> {
+export function local<T extends Tuple<number>>(...coordinates: T): `^${T[0]}` | VectorClass<MappedArray<T, `^${number | ''}`>> {
   if (coordinates.length === 0) {
-    return new VectorClass(['^', '^', '^'] as unknown as MappedArray<T, string>)
+    return new VectorClass(['^', '^', '^'] as unknown as MappedArray<T, '^'>)
   }
 
   if (coordinates.length === 1) {
-    return `^${coordinates[0] || ''}`
+    return `^${coordinates[0]}` as `^${T[0]}`
   }
 
-  return new VectorClass(coordinates.map((coord) => `^${coord || ''}`) as unknown as MappedArray<T, string>)
+  return new VectorClass(coordinates.map((coord) => `^${coord || ''}`) as unknown as MappedArray<T, `^${number | ''}`>)
 }

package/src/variables/Data.ts

@@ -139,6 +139,9 @@ export class DataClass<TYPE extends DATA_TYPES = any> {
 export class DataPointClass<TYPE extends DATA_TYPES = any>
   extends MacroArgument
   implements ConditionTextComponentClass, NBTSerializable {
+  declare readonly __textComponentClassBrand: true
+  declare readonly __conditionClassBrand: true
+
   path
 
   currentTarget: DATA_TARGET[TYPE]
@@ -311,6 +314,9 @@ export class DataPointClass<TYPE extends DATA_TYPES = any>
 }
 
 export class StringDataPointClass<TYPE extends DATA_TYPES = any> extends DataPointClass {
+  declare readonly __textComponentClassBrand: true
+  declare readonly __conditionClassBrand: true
+
   readonly sliceBounds: [number] | [number, number]
 
   constructor(

package/src/variables/DataSets.ts

@@ -45,7 +45,7 @@ type GetKeys<T> = T extends unknown[]
       : number // other array
   : keyof T // not an array
 
-export type DataIndexMapInitial = RootNBT | Record<string, DataPointClass | DataPointPickClass>
+export type DataIndexMapInitial = RootNBT | Record<`${any}${string}`, DataPointClass | DataPointPickClass>
 
 export class DataIndexMapClass<INITIAL extends DataIndexMapInitial> extends IterableDataClass<'map'> {
   entries: Record<string, number> = {}
@@ -481,14 +481,14 @@ export function DataIndexMap<INITIAL extends DataIndexMapInitial>(
 
       return true
     },
-  }) as DataIndexMapClass<INITIAL> & { [K in keyof INITIAL]: DataIndexMapInitial[string] } & {
-    [K in string]: DataIndexMapInitial[string]
+  }) as DataIndexMapClass<INITIAL> & { [K in keyof INITIAL]: DataIndexMapInitial[`${any}${string}`] } & {
+    [K in string]: DataIndexMapInitial[`${any}${string}`]
   }
 }
 
 export type DataIndexMap<INITIAL extends DataIndexMapInitial> = DataIndexMapClass<INITIAL> & {
-  [K in keyof INITIAL]: DataIndexMapInitial[string]
-} & { [K in string]: DataIndexMapInitial[string] }
+  [K in keyof INITIAL]: DataIndexMapInitial[`${any}${string}`]
+} & { [K in string]: DataIndexMapInitial[`${any}${string}`] }
 
 export function DataArray<INITIAL extends DataArrayInitial>(
   pack: SandstonePack,

package/src/variables/ItemPredicate.ts

@@ -174,7 +174,7 @@ export class ItemPredicateClass {
    * ```
    */
   model(): ItemModelBuilder {
-    // Dynamic import to avoid circular dependency
+    // Dynamic import to avoid circular dependency // TODO: Fix
     const { ItemModelBuilder } = require('sandstone/core/resources/resourcepack/itemDefinition')
     const builder = new ItemModelBuilder(this.pack)
     // Copy test groups to the new builder

package/src/variables/Label.ts

@@ -1,14 +1,12 @@
 /* eslint-disable max-len */
 
+import type { NBTSerializable } from 'sandstone/arguments'
 import type { MakeInstanceCallable } from 'sandstone/utils'
 import { makeClassCallable } from 'sandstone/utils'
-import type { SandstonePack } from '../pack'
 import type { ConditionClass, SelectorPickClass } from './abstractClasses'
 import type { SelectorEntityType, SelectorProperties } from './Selector'
 import { SelectorClass } from './Selector'
-import { NBTSerializable } from 'sandstone/arguments';
-
-type SingleEntity = SelectorClass<false, true, boolean> | SelectorPickClass<true, boolean>
+import type { SandstonePack } from 'sandstone'
 
 /**
  * Label tag (/tag) handler
@@ -45,8 +43,29 @@ export class _RawLabelClass implements NBTSerializable {
     if (description) this.description = description
   }
 
-  public LabelHolder = (entity: SingleEntity | '@s' | '@p' | '@r') => {
-    if (typeof entity === 'string') return new EntityLabel(this.pack, new SelectorClass(this.pack, entity), this)
+  public LabelHolder<IS_SINGLE extends boolean, IS_PLAYER extends boolean>(entity: SelectorClass<false, IS_SINGLE, IS_PLAYER> | SelectorPickClass<IS_SINGLE, IS_PLAYER>): EntityLabel<IS_SINGLE, IS_PLAYER>
+
+  public LabelHolder(target: '@e'): EntityLabel<false, false>
+
+  public LabelHolder(target: '@a'): EntityLabel<false, true>
+
+  public LabelHolder(target: '@s' | '@n'): EntityLabel<true, false>
+
+  public LabelHolder<ENTITY_TYPE extends SelectorEntityType>(target: '@p' | '@r', selectorArguments?: Omit<Omit<SelectorProperties<false, false, ENTITY_TYPE, false>, 'type'>, 'limit'>): EntityLabel<true, true>
+
+  public LabelHolder<ENTITY_TYPE extends SelectorEntityType, PROPERTIES extends Omit<SelectorProperties<false, false, ENTITY_TYPE, false>, 'limit'>>(target: '@s' | '@n', selectorArguments: PROPERTIES):
+    EntityLabel<true, PROPERTIES['type'] extends ('player' | 'minecraft:player') ? true : false>
+
+  public LabelHolder<ENTITY_TYPE extends SelectorEntityType, const PROPERTIES extends Omit<SelectorProperties<false, false, ENTITY_TYPE, false>, 'type'>>(target: '@a', selectorArguments: PROPERTIES):
+    EntityLabel<PROPERTIES['limit'] extends 1 ? true : false, true>
+
+  public LabelHolder<ENTITY_TYPE extends SelectorEntityType, const PROPERTIES extends SelectorProperties<false, false, ENTITY_TYPE, false>>(target: '@e', selectorArguments: PROPERTIES):
+    EntityLabel<PROPERTIES['limit'] extends 1 ? true : false, PROPERTIES['type'] extends ('player' | 'minecraft:player') ? true : false>
+
+  public LabelHolder(entity: '@s' | '@p' | '@a' | '@e' | '@n' | '@r' | SelectorPickClass<boolean, boolean>, selectorArguments?: SelectorProperties<boolean, boolean, SelectorEntityType, false>): EntityLabel<boolean, boolean> {
+    if (typeof entity === 'string') {
+      return new EntityLabel(this.pack, new SelectorClass(this.pack, entity, selectorArguments), this)
+    }
     return new EntityLabel(this.pack, entity, this)
   }
 
@@ -60,17 +79,44 @@ export class _RawLabelClass implements NBTSerializable {
    */
   toNBT = () => `'${this.fullName}'`
 
-  __call__ = (entity: SingleEntity | '@s' | '@p' | '@r') => this.LabelHolder(entity)
+  __call__<IS_SINGLE extends boolean, IS_PLAYER extends boolean>(entity: SelectorClass<false, IS_SINGLE, IS_PLAYER> | SelectorPickClass<IS_SINGLE, IS_PLAYER>): EntityLabel<IS_SINGLE, IS_PLAYER>
+
+  __call__(target: '@e'): EntityLabel<false, false>
+
+  __call__(target: '@a'): EntityLabel<false, true>
+
+  __call__(target: '@s' | '@n'): EntityLabel<true, false>
+
+  __call__<ENTITY_TYPE extends SelectorEntityType>(target: '@p' | '@r', selectorArguments?: Omit<Omit<SelectorProperties<false, false, ENTITY_TYPE, false>, 'type'>, 'limit'>): EntityLabel<true, true>
+
+  __call__<ENTITY_TYPE extends SelectorEntityType, PROPERTIES extends Omit<SelectorProperties<false, false, ENTITY_TYPE, false>, 'limit'>>(target: '@s' | '@n', selectorArguments: PROPERTIES):
+    EntityLabel<true, PROPERTIES['type'] extends ('player' | 'minecraft:player') ? true : false>
+
+  __call__<ENTITY_TYPE extends SelectorEntityType, const PROPERTIES extends Omit<SelectorProperties<false, false, ENTITY_TYPE, false>, 'type'>>(target: '@a', selectorArguments: PROPERTIES):
+    EntityLabel<PROPERTIES['limit'] extends 1 ? true : false, true>
+
+  __call__<ENTITY_TYPE extends SelectorEntityType, const PROPERTIES extends SelectorProperties<false, false, ENTITY_TYPE, false>>(target: '@e', selectorArguments: PROPERTIES):
+    EntityLabel<PROPERTIES['limit'] extends 1 ? true : false, PROPERTIES['type'] extends ('player' | 'minecraft:player') ? true : false>
+
+  __call__(entity: '@s' | '@p' | '@a' | '@e' | '@n' | '@r' | SelectorPickClass<boolean, boolean>, selectorArguments?: SelectorProperties<boolean, boolean, SelectorEntityType, false>): EntityLabel<boolean, boolean> {
+    if (typeof entity === 'string') {
+      return new EntityLabel(this.pack, new SelectorClass(this.pack, entity, selectorArguments), this)
+    }
+    return new EntityLabel(this.pack, entity, this)
+  }
 }
 
 export const LabelClass = makeClassCallable(_RawLabelClass)
 export type LabelClass = MakeInstanceCallable<_RawLabelClass>
 
-export class EntityLabel implements ConditionClass, SelectorPickClass<true, false> {
+export class EntityLabel<IS_SINGLE extends boolean = boolean, IS_PLAYER extends boolean = boolean> implements ConditionClass, SelectorPickClass<IS_SINGLE, IS_PLAYER> {
+  declare readonly __textComponentClassBrand: true
+  declare readonly __conditionClassBrand: true
+
   /**
    * Phantom brand property for TypeScript type discrimination.
    */
-  declare readonly __selectorPickBrand: { single: true; player: false }
+  declare readonly __selectorPickBrand: { single: IS_SINGLE; player: IS_PLAYER }
 
   /** Label */
   public label
@@ -78,19 +124,19 @@ export class EntityLabel implements ConditionClass, SelectorPickClass<true, fals
   /**
    * Selects entity with the label
    */
-  public selector: SelectorClass<false, true, false>
+  public selector: SelectorClass<false, IS_SINGLE, IS_PLAYER>
 
   /**
    * Selects entity
    */
-  public originalSelector: string | SelectorClass<false, true, true> | SelectorClass<false, true, false> | SelectorClass<false, true, boolean>
+  public originalSelector: string | SelectorClass<false, IS_SINGLE, IS_PLAYER>
 
   /** Test for label on entity */
   public test = this as ConditionClass
 
   constructor(
     private pack: SandstonePack,
-    entity: SingleEntity,
+    entity: SelectorClass<false, IS_SINGLE, IS_PLAYER> | SelectorPickClass<IS_SINGLE, IS_PLAYER>,
     label: _RawLabelClass,
   ) {
     this.originalSelector = entity._toSelector()
@@ -101,7 +147,7 @@ export class EntityLabel implements ConditionClass, SelectorPickClass<true, fals
       typeof this.originalSelector === 'string'
         ? new SelectorClass(this.pack, '@s')
         : new SelectorClass(this.pack, this.originalSelector.target, { ...this.originalSelector.arguments })
-    ) as SelectorClass<false, true, false>
+    ) as SelectorClass<false, IS_SINGLE, IS_PLAYER>
 
     if (selector.arguments) {
       if (selector.arguments.tag) {
@@ -111,7 +157,7 @@ export class EntityLabel implements ConditionClass, SelectorPickClass<true, fals
           selector.arguments.tag = [...selector.arguments.tag, label.fullName]
         }
       } else selector.arguments.tag = [label.fullName]
-    } else selector.arguments = { tag: [label.fullName] } as SelectorProperties<true, false, SelectorEntityType, false>
+    } else selector.arguments = { tag: [label.fullName] } as SelectorProperties<IS_SINGLE, IS_PLAYER, SelectorEntityType, false>
 
     this.selector = selector
   }
@@ -164,4 +210,9 @@ export class EntityLabel implements ConditionClass, SelectorPickClass<true, fals
    * @internal
    */
   toNBT = () => this.selector._toSelector().toNBT()
+
+  /**
+   * @internal
+   */
+  _toChatComponent = () => this.selector._toSelector()._toChatComponent()
 }

package/src/variables/Objective.ts

@@ -53,7 +53,7 @@ export class _RawObjectiveClass implements NBTSerializable {
 
   toJSON = this.toString
 
-  toNBT = this.toString
+  toNBT = () => `'${this.toString}'`
 
   __call__ = this.ScoreHolder
 }

package/src/variables/Score.ts

@@ -18,7 +18,7 @@ import * as util from 'util'
 import { MacroArgument } from '../core/Macro'
 import type { SandstonePack } from '../pack'
 import { add, formatDebugString } from '../utils'
-import type { ComponentClass } from './abstractClasses'
+import type { TextComponentClass } from './abstractClasses'
 import { SelectorPickClass } from './abstractClasses'
 import type { DATA_TYPES, DataPointClass } from './Data'
 import type { ObjectiveClass } from './Objective'
@@ -70,7 +70,10 @@ type Tuple<T, N extends number, A extends T[] = []> = (
   : Tuple<T, N, [...A, T]>
 )
 
-export class Score extends MacroArgument implements ConditionClass, ComponentClass, NBTSerializable {
+export class Score extends MacroArgument implements ConditionClass, TextComponentClass, NBTSerializable {
+  declare readonly __textComponentClassBrand: true
+  declare readonly __conditionClassBrand: true
+
   commands: SandstoneCommands<false>
 
   constructor(
@@ -96,7 +99,7 @@ export class Score extends MacroArgument implements ConditionClass, ComponentCla
   }
 
   toNBT() {
-    return nbtResolver(this._toChatComponent() as NBTObject).toString()
+    return nbtResolver(this._toChatComponent()).toString()
   }
 
   toJSON() {
@@ -108,7 +111,7 @@ export class Score extends MacroArgument implements ConditionClass, ComponentCla
    */
   _toChatComponent(): JSONTextComponent {
     return {
-      score: { name: this.target, objective: this.objective.name },
+      score: { name: `${this.target}` as `${any}${string}`, objective: this.objective },
     }
   }
 
@@ -502,6 +505,7 @@ export class Score extends MacroArgument implements ConditionClass, ComponentCla
 
     if (typeof args[0] === 'number') {
       return {
+        __conditionClassBrand: true as const,
         _toMinecraftCondition: () =>
           new this.sandstonePack.conditions.Score(this.sandstonePack.core, [
             `${playerScore.target}`,
@@ -514,6 +518,7 @@ export class Score extends MacroArgument implements ConditionClass, ComponentCla
 
     const endArgs = args[1] ? args : [args[0]]
     return {
+      __conditionClassBrand: true as const,
       // eslint-disable-next-line max-len
       _toMinecraftCondition: () =>
         new this.sandstonePack.conditions.Score(this.sandstonePack.core, [
@@ -665,6 +670,7 @@ export class Score extends MacroArgument implements ConditionClass, ComponentCla
    * @param range The range to compare the current score against.
    */
   matches = (range: Range<false>) => ({
+    __conditionClassBrand: true as const,
     _toMinecraftCondition: () =>
       new this.sandstonePack.conditions.Score(this.sandstonePack.core, [
         `${this.target}`,
@@ -675,7 +681,8 @@ export class Score extends MacroArgument implements ConditionClass, ComponentCla
   })
 
   match = (minimum: number, maximum: number, callback: (num: number) => any) => {
-    const { MCFunction, Macro } = this.sandstonePack
+    const { MCFunction, Macro, core } = this.sandstonePack
+    const { getCurrentMCFunctionOrThrow } = core
 
     if (maximum > 1000) {
       console.warn(
@@ -689,12 +696,14 @@ export class Score extends MacroArgument implements ConditionClass, ComponentCla
     // oxlint-disable-next-line no-this-alias
     const score = this
 
-    for (let i = minimum; i < maximum; i++) {
-      MCFunction(`__sandstone:score_match/${matcher}/${i}`, () => callback(i))
+    const parent = getCurrentMCFunctionOrThrow()
+
+    for (let i = minimum; i <= maximum; i++) {
+      MCFunction(`./score_match/${matcher}/${i}`, () => callback(i))
     }
 
-    return MCFunction(`__sandstone:score_match/${matcher}`, [score], () =>
-      Macro.returnCmd.run.functionCmd(Macro`__sandstone:score_match/${matcher}/${score}`),
+    return MCFunction(`./score_match/${matcher}`, [score], () =>
+      Macro.returnCmd.run.functionCmd(Macro`${parent.resource.name}/score_match/${matcher}/${score}`),
     )
   }
 

package/src/variables/Selector.ts

@@ -302,6 +302,9 @@ export class SelectorClass<
   IsSingle extends boolean = false,
   IsPlayer extends boolean = false,
 > implements ConditionTextComponentClass, SelectorPickClass<IsSingle, IsPlayer>, ConditionClass, NBTSerializable {
+  declare readonly __textComponentClassBrand: true
+  declare readonly __conditionClassBrand: true
+
   /**
    * Phantom brand property for TypeScript to distinguish between different
    * SelectorClass type parameter combinations. Does not exist at runtime.
@@ -409,22 +412,29 @@ export class SelectorClass<
       distance: (range_: Range<MACRO>) => result.push(['distance', rangeParser(this.sandstonePack.core, range_)]),
     } as const
 
-    for (const [baseName, modifier] of Object.entries(modifiers)) {
-      const name = baseName as keyof typeof args
-      const value = args[name]
-
-      if (value !== undefined) {
-        modifier(value as any)
-        delete args[name]
-      }
-    }
-
-    Object.entries(args).forEach(([key, value]) => {
-      if (value !== undefined) {
+    Object.entries(args).forEach(([key_, value]) => {
+      const key = key_ as Extract<keyof typeof args, string>
+      if (key in modifiers) {
+        const modifierName = key as keyof typeof modifiers
+        modifiers[modifierName](value as any)
+      } else if (value !== undefined) {
         result.push([key, `${value}`])
       }
     })
 
+    // TODO: This probably should do more than drag the type to the front
+    const entityType = result.findIndex(([key]) => key === 'type')
+
+    if (entityType !== -1) {
+      result.unshift(...result.splice(entityType, 1))
+    }
+
+    const predicate = result.findIndex(([key]) => key === 'predicate')
+
+    if (predicate !== -1) {
+      result.push(...result.splice(predicate, 1))
+    }
+
     return `${this.target}[${result.map(([key, value]) => `${key}=${value}`).join(', ')}]`
   }
 
@@ -457,7 +467,7 @@ export class SelectorClass<
   }
 
   toNBT() {
-    return this.toString()
+    return `'${this.toString()}'`
   }
 
   [util.inspect.custom]() {

package/src/variables/Trigger.ts

@@ -18,7 +18,7 @@ export class TriggerClass<HANDLE extends TriggerHandler> {
     protected readonly callback: HANDLE,
     public readonly pollingEvery: number,
   ) {
-    this.objective = new ObjectiveClass(sandstoneCore.pack, name, 'dummy', undefined, { creator: 'sandstone' })
+    this.objective = new ObjectiveClass(sandstoneCore.pack, name, 'trigger', undefined, { creator: 'sandstone' })
 
     const { registerNewObjective, MCFunction, commands } = sandstoneCore.pack
 
@@ -32,13 +32,13 @@ export class TriggerClass<HANDLE extends TriggerHandler> {
     }
 
     sandstoneCore.checkTriggers[pollingEvery].push(() => {
-      commands.execute.as(`@a[scores={${name}=1..}]`).run(() => {
+      commands.execute.as(`@a[scores={${name}=1..}]`).at('@s').run(() => {
         const score = this.objective('@s')
 
         if (callback instanceof _RawMCFunctionClass || typeof callback === 'function') {
           callback()
         } else if (callback[0] === 'num') {
-          score.match(1, callback[1], callback[2])
+          score.match(1, callback[1], callback[2])()
         } else {
           callback[1](score)
         }

package/src/variables/UUID.ts

@@ -2,11 +2,11 @@
 /* eslint-disable no-plusplus */
 /* eslint-disable max-len */
 
-import type { JSONTextComponent, NBTSerializable } from 'sandstone/arguments'
+import type { JSONTextComponent } from 'sandstone/arguments'
 import type { ExecuteCommand } from 'sandstone/commands'
 import { createDeferredMacroExecute, ExecuteCommand as ExecuteCommandClass } from 'sandstone/commands/implementations/entity/execute'
 import type { SandstoneCore } from 'sandstone/core'
-import type { ConditionTextComponentClass } from './abstractClasses'
+import type { ConditionClass } from './abstractClasses'
 import { SelectorPickClass } from './abstractClasses'
 import type { DataPointClass } from './Data'
 import { NBTIntArray } from './nbt'
@@ -74,7 +74,10 @@ export type UUIDOptions = {
 }
 
 export class UUIDClass<PrimarySource extends 'known' | 'scores' | 'selector' | 'data'>
-implements ConditionTextComponentClass, SelectorPickClass<true, boolean>, NBTSerializable {
+implements ConditionClass, SelectorPickClass<true, boolean> {
+  declare readonly __textComponentClassBrand: true
+  declare readonly __conditionClassBrand: true
+
   /**
    * Phantom brand property for TypeScript type discrimination.
    * Uses `boolean` for player since a UUID can reference any entity type.
@@ -542,7 +545,7 @@ implements ConditionTextComponentClass, SelectorPickClass<true, boolean>, NBTSer
     const selector = this._toSelector()
 
     if (typeof selector === 'string') {
-      return selector
+      return `'${selector}'`
     }
     return selector.toNBT()
   }