@tapez/core 0.0.0-alpha.2 → 0.0.0-alpha.4

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,UAAU;AACV,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAG/C,UAAU;AACV,OAAO,EACL,KAAK,EACL,KAAK,EACL,KAAK,EACL,KAAK,EACL,KAAK,EACL,KAAK,EACL,KAAK,EACL,KAAK,EACL,KAAK,EACN,MAAM,WAAW,CAAA;AAGlB,WAAW;AACX,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAGpD,UAAU;AACV,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAGjC,SAAS;AACT,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AAGjC,YAAY;AACZ,OAAO,EAAE,QAAQ,IAAI,KAAK,EAAE,MAAM,SAAS,CAAA;AAG3C,eAAe;AACf,OAAO,EAAE,WAAW,EAAwB,MAAM,gBAAgB,CAAA;AAElE,qBAAqB;AACrB,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAExE,sCAAsC;AACtC,OAAO,EAAE,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAA"}
+{"version":3,"sources":["../src/types.ts","../src/vectors.ts","../src/matrix.ts","../src/layout.ts","../src/struct.ts","../src/array.ts","../src/const.ts","../src/gpu-buffer-utils.ts","../src/typed-buffer.ts","../src/bind-helpers.ts"],"sourcesContent":["/**\n * TapeZ type system — GPU data type definitions.\n *\n * Each type carries its WGSL name, byte size, and alignment\n * following the WGSL specification for host-shareable types.\n */\n\n// ---------------------------------------------------------------------------\n// Core type interface\n// ---------------------------------------------------------------------------\n\nexport interface TapezType {\n  /** Unique tag for runtime discrimination */\n  readonly kind: string\n  /** WGSL type name, e.g. 'f32', 'vec4<f32>' */\n  readonly wgslType: string\n  /** Byte size of this type in a buffer */\n  readonly byteSize: number\n  /** Required alignment in bytes (WGSL spec) */\n  readonly alignment: number\n}\n\n// ---------------------------------------------------------------------------\n// Scalar types\n// ---------------------------------------------------------------------------\n\nexport interface TapezScalar extends TapezType {\n  readonly kind: 'scalar'\n  /** Which typed array setter to use */\n  readonly arrayKind: 'f32' | 'u32' | 'i32'\n}\n\nfunction scalar(wgslType: string, arrayKind: TapezScalar['arrayKind']): TapezScalar {\n  return Object.freeze({ kind: 'scalar', wgslType, byteSize: 4, alignment: 4, arrayKind })\n}\n\nexport const f32: TapezScalar = scalar('f32', 'f32')\nexport const u32: TapezScalar = scalar('u32', 'u32')\nexport const i32: TapezScalar = scalar('i32', 'i32')\n\n// ---------------------------------------------------------------------------\n// Atomic wrapper — same layout as the inner scalar, different WGSL type\n// ---------------------------------------------------------------------------\n\nexport interface TapezAtomic extends TapezType {\n  readonly kind: 'atomic'\n  /** The wrapped scalar type */\n  readonly inner: TapezScalar\n  /** Which typed array setter to use (same as inner) */\n  readonly arrayKind: 'f32' | 'u32' | 'i32'\n}\n\nexport function atomic(inner: TapezScalar): TapezAtomic {\n  return Object.freeze({\n    kind: 'atomic',\n    wgslType: `atomic<${inner.wgslType}>`,\n    byteSize: inner.byteSize,\n    alignment: inner.alignment,\n    inner,\n    arrayKind: inner.arrayKind,\n  })\n}\n","/**\n * TapeZ vector types — vec2, vec3, vec4 for f32/u32/i32.\n *\n * WGSL alignment rules:\n *   vec2<T> → size 8,  align 8\n *   vec3<T> → size 12, align 16\n *   vec4<T> → size 16, align 16\n */\n\nimport type { TapezScalar, TapezType } from './types'\nimport { f32, u32, i32 } from './types'\n\n// ---------------------------------------------------------------------------\n// Vector type\n// ---------------------------------------------------------------------------\n\nexport interface TapezVector extends TapezType {\n  readonly kind: 'vector'\n  /** Number of components (2, 3, or 4) */\n  readonly components: number\n  /** Component scalar type */\n  readonly componentType: TapezScalar\n}\n\nfunction vec(components: 2 | 3 | 4, componentType: TapezScalar): TapezVector {\n  const suffix = componentType.wgslType[0] // 'f', 'u', 'i'\n  const wgslType = `vec${components}<${componentType.wgslType}>`\n\n  // WGSL alignment rules\n  let byteSize: number\n  let alignment: number\n  switch (components) {\n    case 2:\n      byteSize = 8\n      alignment = 8\n      break\n    case 3:\n      byteSize = 12\n      alignment = 16\n      break\n    case 4:\n      byteSize = 16\n      alignment = 16\n      break\n  }\n\n  return Object.freeze({ kind: 'vector', wgslType, byteSize, alignment, components, componentType })\n}\n\n// Float vectors\nexport const vec2f: TapezVector = vec(2, f32)\nexport const vec3f: TapezVector = vec(3, f32)\nexport const vec4f: TapezVector = vec(4, f32)\n\n// Unsigned int vectors\nexport const vec2u: TapezVector = vec(2, u32)\nexport const vec3u: TapezVector = vec(3, u32)\nexport const vec4u: TapezVector = vec(4, u32)\n\n// Signed int vectors\nexport const vec2i: TapezVector = vec(2, i32)\nexport const vec3i: TapezVector = vec(3, i32)\nexport const vec4i: TapezVector = vec(4, i32)\n","/**\n * TapeZ matrix types — mat2x2f, mat3x3f, mat4x4f.\n *\n * WGSL matrices are column-major arrays of column vectors.\n *   mat2x2<f32> → 2 columns of vec2<f32> → size 16,  align 8\n *   mat3x3<f32> → 3 columns of vec3<f32> → size 48,  align 16\n *   mat4x4<f32> → 4 columns of vec4<f32> → size 64,  align 16\n */\n\nimport type { TapezType } from './types'\n\n// ---------------------------------------------------------------------------\n// Matrix type\n// ---------------------------------------------------------------------------\n\nexport interface TapezMatrix extends TapezType {\n  readonly kind: 'matrix'\n  /** Number of columns */\n  readonly columns: number\n  /** Number of rows */\n  readonly rows: number\n}\n\nfunction mat(cols: number, rows: number, byteSize: number, alignment: number): TapezMatrix {\n  return Object.freeze({\n    kind: 'matrix',\n    wgslType: `mat${cols}x${rows}<f32>`,\n    byteSize,\n    alignment,\n    columns: cols,\n    rows: rows\n  })\n}\n\n// mat2x2f: 2 columns of vec2f (8 bytes each) = 16 bytes, align 8\nexport const mat2x2f: TapezMatrix = mat(2, 2, 16, 8)\n\n// mat3x3f: 3 columns of vec3f (12 bytes each, padded to 16) = 48 bytes, align 16\nexport const mat3x3f: TapezMatrix = mat(3, 3, 48, 16)\n\n// mat4x4f: 4 columns of vec4f (16 bytes each) = 64 bytes, align 16\nexport const mat4x4f: TapezMatrix = mat(4, 4, 64, 16)\n","/**\n * WGSL struct layout computation — alignment, padding, field offsets.\n *\n * Implements the WGSL spec's struct layout algorithm:\n * https://www.w3.org/TR/WGSL/#structure-member-layout\n */\n\nimport type { TapezType } from './types'\n\n// ---------------------------------------------------------------------------\n// Layout helpers\n// ---------------------------------------------------------------------------\n\n/** Round `offset` up to the next multiple of `alignment`. */\nexport function roundUp(alignment: number, offset: number): number {\n  return Math.ceil(offset / alignment) * alignment\n}\n\n// ---------------------------------------------------------------------------\n// Struct field layout\n// ---------------------------------------------------------------------------\n\nexport interface FieldLayout {\n  /** Field name */\n  readonly name: string\n  /** Field type */\n  readonly type: TapezType\n  /** Byte offset from struct start */\n  readonly offset: number\n}\n\nexport interface StructLayout {\n  /** Ordered field layouts */\n  readonly fields: readonly FieldLayout[]\n  /** Total byte size (padded to struct alignment) */\n  readonly byteSize: number\n  /** Struct alignment = max(field alignments) */\n  readonly alignment: number\n  /** Map from field name to byte offset */\n  readonly offsets: Record<string, number>\n}\n\n/**\n * Compute the byte layout of a struct given its fields in order.\n * Follows WGSL struct member layout rules.\n */\nexport function computeStructLayout(\n  fields: readonly { name: string; type: TapezType }[]\n): StructLayout {\n  const layouts: FieldLayout[] = []\n  const offsets: Record<string, number> = {}\n  let offset = 0\n  let maxAlignment = 1\n\n  for (const { name, type } of fields) {\n    // Align the field\n    offset = roundUp(type.alignment, offset)\n    layouts.push({ name, type, offset })\n    offsets[name] = offset\n\n    // Advance past this field\n    offset += type.byteSize\n\n    // Track max alignment for struct alignment\n    if (type.alignment > maxAlignment) {\n      maxAlignment = type.alignment\n    }\n  }\n\n  // Struct size is rounded up to struct alignment\n  const byteSize = roundUp(maxAlignment, offset)\n\n  return { fields: layouts, byteSize, alignment: maxAlignment, offsets }\n}\n","/**\n * TapeZ struct definition — the core of the schema system.\n *\n * Usage:\n *   const MyConfig = tapez.struct('MyConfig', {\n *     midPrice: tapez.f32,\n *     rowHeight: tapez.f32,\n *     decimals: tapez.u32,\n *   })\n *\n *   MyConfig.byteSize    // 12\n *   MyConfig.offsets      // { midPrice: 0, rowHeight: 4, decimals: 8 }\n *   MyConfig.toWGSL()    // \"struct MyConfig {\\n  midPrice: f32,\\n  ...\"\n */\n\nimport type { TapezType, TapezScalar } from './types'\nimport { atomic } from './types'\nimport { computeStructLayout, type FieldLayout, type StructLayout } from './layout'\n\n// ---------------------------------------------------------------------------\n// Struct type\n// ---------------------------------------------------------------------------\n\nexport interface TapezStruct<F extends Record<string, TapezType> = Record<string, TapezType>>\n  extends TapezType {\n  readonly kind: 'struct'\n  /** Struct name (used in WGSL output) */\n  readonly name: string\n  /** Field type definitions, keyed by name */\n  readonly fields: F\n  /** Byte offset of each field */\n  readonly offsets: { readonly [K in keyof F]: number }\n  /** Field names in definition order */\n  readonly fieldOrder: readonly (keyof F & string)[]\n  /** Full computed layout with per-field metadata */\n  readonly layout: StructLayout\n  /** Generate WGSL struct declaration */\n  toWGSL(): string\n  /**\n   * Create a new struct with specified fields wrapped in atomic<>.\n   * Same memory layout — atomic<u32> and u32 are identical in size/alignment.\n   * Only u32 and i32 fields can be made atomic.\n   */\n  withAtomics<K extends keyof F & string>(\n    name: string,\n    atomicFields: K[]\n  ): TapezStruct<F>\n}\n\n/**\n * Define a GPU struct schema.\n *\n * Fields are laid out in definition order following WGSL alignment rules.\n * The returned object is frozen and can be shared across entities.\n */\nexport function struct<F extends Record<string, TapezType>>(\n  name: string,\n  fields: F\n): TapezStruct<F> {\n  const fieldOrder = Object.keys(fields) as (keyof F & string)[]\n  const fieldEntries: { name: string; type: TapezType }[] = fieldOrder.map((k) => {\n    const t = fields[k]\n    if (!t) throw new Error(`struct ${name}: missing field type for \"${k}\"`)\n    return { name: k, type: t }\n  })\n  const layout = computeStructLayout(fieldEntries)\n\n  const offsets = {} as { [K in keyof F]: number }\n  for (const k of fieldOrder) {\n    const off = layout.offsets[k]\n    if (off === undefined) throw new Error(`struct ${name}: missing offset for \"${k}\"`)\n    ;(offsets as Record<string, number>)[k] = off\n  }\n\n  const result: TapezStruct<F> = {\n    kind: 'struct',\n    wgslType: name,\n    name,\n    byteSize: layout.byteSize,\n    alignment: layout.alignment,\n    fields,\n    offsets,\n    fieldOrder,\n    layout,\n    toWGSL() {\n      return structToWGSL(result)\n    },\n    withAtomics<K extends keyof F & string>(\n      atomicName: string,\n      atomicFields: K[]\n    ): TapezStruct<F> {\n      const atomicSet = new Set<string>(atomicFields)\n      const newFields = {} as Record<string, TapezType>\n      for (const k of fieldOrder) {\n        const fieldType = fields[k]\n        if (!fieldType) throw new Error(`withAtomics: missing field \"${k}\"`)\n        if (atomicSet.has(k)) {\n          if (fieldType.kind !== 'scalar') {\n            throw new Error(`withAtomics: field \"${k}\" is not a scalar (got ${fieldType.kind})`)\n          }\n          newFields[k] = atomic(fieldType as unknown as TapezScalar)\n        } else {\n          newFields[k] = fieldType\n        }\n      }\n      return struct(atomicName, newFields as F)\n    }\n  }\n\n  return Object.freeze(result)\n}\n\n// ---------------------------------------------------------------------------\n// WGSL emission\n// ---------------------------------------------------------------------------\n\nfunction structToWGSL(s: TapezStruct): string {\n  const lines = s.layout.fields.map((f: FieldLayout) => `  ${f.name}: ${f.type.wgslType},`)\n  return `struct ${s.name} {\\n${lines.join('\\n')}\\n}`\n}\n","/**\n * TapeZ array type — fixed-size GPU arrays.\n *\n * WGSL array layout:\n *   Element stride = roundUp(alignment, sizeof(element))\n *   Array size     = count * stride\n *   Array alignment = element alignment\n */\n\nimport type { TapezType } from './types'\nimport { roundUp } from './layout'\n\n// ---------------------------------------------------------------------------\n// Array type\n// ---------------------------------------------------------------------------\n\nexport interface TapezArray extends TapezType {\n  readonly kind: 'array'\n  /** Element type */\n  readonly elementType: TapezType\n  /** Number of elements */\n  readonly count: number\n  /** Byte stride between consecutive elements (includes padding) */\n  readonly stride: number\n}\n\n/**\n * Define a fixed-size GPU array.\n *\n * Element stride follows WGSL array layout rules:\n * stride = roundUp(element.alignment, element.byteSize)\n */\nexport function arrayOf(elementType: TapezType, count: number): TapezArray {\n  const stride = roundUp(elementType.alignment, elementType.byteSize)\n  const byteSize = count * stride\n  const alignment = elementType.alignment\n\n  return Object.freeze({\n    kind: 'array',\n    wgslType: `array<${elementType.wgslType}, ${count}>`,\n    byteSize,\n    alignment,\n    elementType,\n    count,\n    stride\n  })\n}\n","/**\n * TapeZ constants — shared between TypeScript and WGSL.\n *\n * Usage:\n *   const MAX_ROWS = tapez.const('MAX_ROWS', tapez.u32, 4096)\n *\n *   MAX_ROWS.value     // 4096 (use in TypeScript)\n *   MAX_ROWS.toWGSL()  // 'const MAX_ROWS: u32 = 4096u;' (injected into WGSL)\n */\n\nimport type { TapezScalar } from './types'\n\n// ---------------------------------------------------------------------------\n// Constant type\n// ---------------------------------------------------------------------------\n\nexport interface TapezConst<T extends TapezScalar = TapezScalar> {\n  readonly kind: 'const'\n  /** Constant name (used in both TS and WGSL) */\n  readonly name: string\n  /** Scalar type */\n  readonly type: T\n  /** The value */\n  readonly value: number\n  /** Generate WGSL const declaration */\n  toWGSL(): string\n}\n\n/**\n * Define a shared constant available in both TypeScript and WGSL.\n */\nexport function constant<T extends TapezScalar>(\n  name: string,\n  type: T,\n  value: number\n): TapezConst<T> {\n  return Object.freeze({\n    kind: 'const',\n    name,\n    type,\n    value,\n    toWGSL() {\n      return constToWGSL(name, type, value)\n    }\n  })\n}\n\n// ---------------------------------------------------------------------------\n// WGSL emission\n// ---------------------------------------------------------------------------\n\nfunction constToWGSL(name: string, type: TapezScalar, value: number): string {\n  let literal: string\n  switch (type.arrayKind) {\n    case 'f32':\n      // Ensure float literal has a decimal point\n      literal = Number.isInteger(value) ? `${value}.0` : `${value}`\n      break\n    case 'u32':\n      literal = `${value >>> 0}u`\n      break\n    case 'i32':\n      literal = `${value | 0}i`\n      break\n  }\n  return `const ${name}: ${type.wgslType} = ${literal};`\n}\n","const DEFAULT_INDIRECT_BUFFER_BYTE_SIZE = 16\n\n// ============================================================================\n// Static Reset Constants (zero-allocation hot path resets)\n// ============================================================================\n\n/** Static 16-byte ArrayBuffer containing [0, 0, 0, 0] for GPU buffer resets */\nexport const ZERO_U32_4_BUFFER = new ArrayBuffer(16) // ArrayBuffer is zero-initialized by spec\n\n/** Static 16-byte ArrayBuffer containing [6, 0, 0, 0] for indirect draw buffer init */\nexport const INDIRECT_INIT_6_BUFFER = new ArrayBuffer(16)\nnew Uint32Array(INDIRECT_INIT_6_BUFFER).set([6, 0, 0, 0])\n\n// ============================================================================\n// Buffer Factory Functions\n// ============================================================================\n\nexport function makeIndirectBuffer(\n  device: GPUDevice,\n  label: string,\n  byteSize = DEFAULT_INDIRECT_BUFFER_BYTE_SIZE\n): GPUBuffer {\n  return device.createBuffer({\n    label,\n    size: byteSize,\n    usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST\n  })\n}\n\nexport function makeStorageBuffer(\n  device: GPUDevice,\n  label: string,\n  byteSize: number,\n  extraUsageFlags: GPUBufferUsageFlags = 0\n): GPUBuffer {\n  return device.createBuffer({\n    label,\n    size: byteSize,\n    usage: GPUBufferUsage.STORAGE | extraUsageFlags\n  })\n}\n\nexport class UniformBuffer {\n  readonly buffer: GPUBuffer\n  readonly scratch: ArrayBuffer\n  readonly u32: Uint32Array\n  readonly i32: Int32Array\n  readonly f32: Float32Array\n  readonly byteSize: number\n\n  constructor(device: GPUDevice, label: string, byteSize: number, usage?: GPUBufferUsageFlags) {\n    if (byteSize <= 0) {\n      throw new Error(`UniformBuffer size must be positive, got ${byteSize}`)\n    }\n    if (byteSize % 4 !== 0) {\n      throw new Error(`UniformBuffer size must be 4-byte aligned, got ${byteSize}`)\n    }\n\n    this.byteSize = byteSize\n    this.buffer = device.createBuffer({\n      label,\n      size: byteSize,\n      usage: usage ?? (GPUBufferUsage.UNIFORM | GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST)\n    })\n\n    this.scratch = new ArrayBuffer(byteSize)\n    this.u32 = new Uint32Array(this.scratch)\n    this.i32 = new Int32Array(this.scratch)\n    this.f32 = new Float32Array(this.scratch)\n  }\n\n  write(queue: GPUQueue, offsetBytes = 0): void {\n    queue.writeBuffer(this.buffer, offsetBytes, this.scratch)\n  }\n\n  destroy(): void {\n    this.buffer.destroy()\n  }\n}\n\n/**\n * UniformBuffer with dirty tracking for conditional GPU uploads.\n * Use set* methods to write values - they only mark dirty if value changed.\n * Call writeIfDirty(queue) once per frame to upload if any values changed.\n *\n * Eliminates boilerplate \"cache field + comparison + write\" patterns in entities.\n */\nexport class DirtyUniformBuffer extends UniformBuffer {\n  private _dirty = true\n\n  /** Set a u32 value at index, marks dirty only if value changed */\n  setU32(i: number, v: number): void {\n    if (this.u32[i] !== v) {\n      this.u32[i] = v\n      this._dirty = true\n    }\n  }\n\n  /** Set an i32 value at index, marks dirty only if value changed */\n  setI32(i: number, v: number): void {\n    if (this.i32[i] !== v) {\n      this.i32[i] = v\n      this._dirty = true\n    }\n  }\n\n  /** Set an f32 value at index, marks dirty only if value changed */\n  setF32(i: number, v: number): void {\n    if (this.f32[i] !== v) {\n      this.f32[i] = v\n      this._dirty = true\n    }\n  }\n\n  /** Force dirty state (use when external factors require re-upload) */\n  markDirty(): void {\n    this._dirty = true\n  }\n\n  /** Returns true if any values have changed since last write */\n  get isDirty(): boolean {\n    return this._dirty\n  }\n\n  /** Upload to GPU only if dirty, then clear dirty flag */\n  writeIfDirty(queue: GPUQueue, offsetBytes = 0): void {\n    if (!this._dirty) return\n    this.write(queue, offsetBytes)\n    this._dirty = false\n  }\n}\n","/**\n * TypedBuffer — GPU buffer backed by a tapez type.\n *\n * Accepts any TapezType: scalars, vectors, arrays, structs.\n * For structs, provides named field setters/getters with dirty tracking.\n * For all types, provides the raw GPUBuffer, typed array views, and lifecycle.\n *\n * Usage:\n *   // Struct — named setters\n *   const config = TypedBuffer.createUniform(device, MyStruct, 'config')\n *   config.set.midPrice(1.5)\n *   config.writeIfDirty(queue)\n *\n *   // Array — raw typed array access\n *   const rows = TypedBuffer.createStorage(device, tapez.arrayOf(tapez.f32, 4096), 'rows')\n *   rows.raw.f32.set(myData)\n *   rows.write(queue)\n *\n *   // Indirect draw\n *   const indirect = TypedBuffer.createIndirect(device, IndirectDraw, 'indirect')\n */\n\nimport { DirtyUniformBuffer } from './gpu-buffer-utils'\nimport type { TapezType, TapezScalar, TapezAtomic } from './types'\nimport type { TapezVector } from './vectors'\nimport type { TapezStruct } from './struct'\nimport type { FieldLayout } from './layout'\n\n// ---------------------------------------------------------------------------\n// Type-level helpers\n// ---------------------------------------------------------------------------\n\n/** Maps a TapezType to its TypeScript setter value type */\ntype SetterValue<T extends TapezType> = T extends TapezScalar | TapezAtomic\n  ? number\n  : T extends TapezVector\n    ? number[] | Float32Array | Uint32Array | Int32Array\n    : number[] | Float32Array\n\n/** Setter functions keyed by field name */\ntype Setters<F extends Record<string, TapezType>> = {\n  readonly [K in keyof F]: (value: SetterValue<F[K]>) => void\n}\n\n/** Getter functions keyed by field name */\ntype Getters<F extends Record<string, TapezType>> = {\n  readonly [K in keyof F]: () => SetterValue<F[K]>\n}\n\n/** Extract the fields type from a TapezStruct, or never */\ntype FieldsOf<T extends TapezType> = T extends TapezStruct<infer F> ? F : never\n\n// ---------------------------------------------------------------------------\n// Base interface — used by registerBuffer/bufferEntry without generics\n// ---------------------------------------------------------------------------\n\nexport interface TypedBufferBase {\n  readonly buffer: GPUBuffer\n  readonly byteSize: number\n  readonly isDirty: boolean\n  markDirty(): void\n  writeIfDirty(queue: GPUQueue): void\n  write(queue: GPUQueue): void\n  writeRaw(queue: GPUQueue, data: BufferSource | SharedArrayBuffer, bufferOffset?: number, dataOffset?: number, size?: number): void\n  copyTo(encoder: GPUCommandEncoder, dest: TypedBufferBase, srcOffset?: number, dstOffset?: number, size?: number): void\n  copyFrom(encoder: GPUCommandEncoder, src: TypedBufferBase, srcOffset?: number, dstOffset?: number, size?: number): void\n  drawIndirect(pass: GPURenderPassEncoder, offset?: number): void\n  dispatchIndirect(pass: GPUComputePassEncoder, offset?: number): void\n  mapRead(): Promise<ArrayBuffer>\n  unmap(): void\n  destroy(): void\n}\n\n// ---------------------------------------------------------------------------\n// TypedBuffer\n// ---------------------------------------------------------------------------\n\nexport class TypedBuffer<T extends TapezType = TapezType> implements TypedBufferBase {\n  /** The underlying DirtyUniformBuffer (provides typed array views: .f32, .u32, .i32) */\n  readonly raw: DirtyUniformBuffer\n  /** The tapez type this buffer was created from */\n  readonly type: T\n\n  /**\n   * Named field setters. Only available for struct types.\n   * For non-struct buffers this is an empty object.\n   */\n  readonly set: T extends TapezStruct<infer F> ? Setters<F> : Record<string, never>\n\n  /**\n   * Named field getters. Only available for struct types.\n   * For non-struct buffers this is an empty object.\n   */\n  readonly get: T extends TapezStruct<infer F> ? Getters<F> : Record<string, never>\n\n  private constructor(raw: DirtyUniformBuffer, type: T) {\n    this.raw = raw\n    this.type = type\n\n    if (type.kind === 'struct') {\n      const struct = type as unknown as TapezStruct\n      this.set = buildSetters(raw, struct) as TypedBuffer<T>['set']\n      this.get = buildGetters(raw, struct) as TypedBuffer<T>['get']\n    } else {\n      this.set = {} as TypedBuffer<T>['set']\n      this.get = {} as TypedBuffer<T>['get']\n    }\n  }\n\n  /** The raw GPUBuffer — for texture/sampler bind group entries only */\n  get buffer(): GPUBuffer {\n    return this.raw.buffer\n  }\n\n  /** Total byte size of the buffer */\n  get byteSize(): number {\n    return this.raw.byteSize\n  }\n\n  /** Whether any values have changed since last write */\n  get isDirty(): boolean {\n    return this.raw.isDirty\n  }\n\n  /** Force dirty state (for external invalidation) */\n  markDirty(): void {\n    this.raw.markDirty()\n  }\n\n  /** Upload to GPU only if dirty, then clear dirty flag */\n  writeIfDirty(queue: GPUQueue): void {\n    this.raw.writeIfDirty(queue)\n  }\n\n  /** Upload to GPU unconditionally */\n  write(queue: GPUQueue): void {\n    this.raw.write(queue)\n  }\n\n  /**\n   * Bulk set multiple struct fields at once.\n   * Only available for struct-typed buffers.\n   */\n  writeFields(values: Partial<{ [K in keyof FieldsOf<T>]: SetterValue<FieldsOf<T>[K]> }>): void {\n    for (const key in values) {\n      if (Object.prototype.hasOwnProperty.call(values, key)) {\n        const setter = (this.set as Record<string, (v: unknown) => void>)[key]\n        if (setter) setter(values[key as keyof typeof values])\n      }\n    }\n  }\n\n  /** Destroy the underlying GPU buffer */\n  destroy(): void {\n    this.raw.destroy()\n  }\n\n  // ---------------------------------------------------------------------------\n  // WebGPU API wrappers — so entity code never touches .buffer directly\n  // ---------------------------------------------------------------------------\n\n  /** Write raw data to this buffer via queue.writeBuffer */\n  writeRaw(queue: GPUQueue, data: BufferSource | SharedArrayBuffer, bufferOffset = 0, dataOffset?: number, size?: number): void {\n    queue.writeBuffer(this.raw.buffer, bufferOffset, data, dataOffset, size)\n  }\n\n  /** Copy data from this buffer to another TypedBuffer */\n  copyTo(encoder: GPUCommandEncoder, dest: TypedBuffer, srcOffset = 0, dstOffset = 0, size?: number): void {\n    encoder.copyBufferToBuffer(this.raw.buffer, srcOffset, dest.raw.buffer, dstOffset, size ?? this.raw.byteSize)\n  }\n\n  /** Copy data from another TypedBuffer into this buffer */\n  copyFrom(encoder: GPUCommandEncoder, src: TypedBuffer, srcOffset = 0, dstOffset = 0, size?: number): void {\n    encoder.copyBufferToBuffer(src.raw.buffer, srcOffset, this.raw.buffer, dstOffset, size ?? src.raw.byteSize)\n  }\n\n  /** Use this buffer for drawIndirect */\n  drawIndirect(pass: GPURenderPassEncoder, offset = 0): void {\n    pass.drawIndirect(this.raw.buffer, offset)\n  }\n\n  /** Use this buffer for dispatchWorkgroupsIndirect */\n  dispatchIndirect(pass: GPUComputePassEncoder, offset = 0): void {\n    pass.dispatchWorkgroupsIndirect(this.raw.buffer, offset)\n  }\n\n  /** Map buffer for reading (for readback buffers). Returns the mapped ArrayBuffer. */\n  async mapRead(): Promise<ArrayBuffer> {\n    await this.raw.buffer.mapAsync(GPUMapMode.READ)\n    return this.raw.buffer.getMappedRange()\n  }\n\n  /** Unmap a previously mapped buffer */\n  unmap(): void {\n    this.raw.buffer.unmap()\n  }\n\n  // ---------------------------------------------------------------------------\n  // Factory methods\n  // ---------------------------------------------------------------------------\n\n  /** Create a buffer with explicit usage flags. Accepts any TapezType. */\n  static create<T extends TapezType>(\n    device: GPUDevice,\n    type: T,\n    label: string,\n    usage: GPUBufferUsageFlags\n  ): TypedBuffer<T> {\n    const raw = new DirtyUniformBuffer(device, label, type.byteSize, usage | GPUBufferUsage.COPY_DST)\n    return new TypedBuffer(raw, type)\n  }\n\n  /** Create a uniform buffer (UNIFORM | STORAGE | COPY_DST) */\n  static createUniform<T extends TapezType>(\n    device: GPUDevice,\n    type: T,\n    label: string\n  ): TypedBuffer<T> {\n    return TypedBuffer.create(device, type, label,\n      GPUBufferUsage.UNIFORM | GPUBufferUsage.STORAGE)\n  }\n\n  /** Create a storage buffer (STORAGE | COPY_DST). Pass extraFlags for COPY_SRC etc. */\n  static createStorage<T extends TapezType>(\n    device: GPUDevice,\n    type: T,\n    label: string,\n    extraFlags: GPUBufferUsageFlags = 0\n  ): TypedBuffer<T> {\n    return TypedBuffer.create(device, type, label,\n      GPUBufferUsage.STORAGE | extraFlags)\n  }\n\n  /** Create an indirect draw/dispatch buffer (INDIRECT | STORAGE | COPY_DST) */\n  static createIndirect<T extends TapezType>(\n    device: GPUDevice,\n    type: T,\n    label: string\n  ): TypedBuffer<T> {\n    return TypedBuffer.create(device, type, label,\n      GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE)\n  }\n\n  /** Create a readback buffer (MAP_READ | COPY_DST). For GPU→CPU data transfer. */\n  static createReadback<T extends TapezType>(\n    device: GPUDevice,\n    type: T,\n    label: string\n  ): TypedBuffer<T> {\n    return TypedBuffer.create(device, type, label,\n      GPUBufferUsage.MAP_READ)\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Internal: build setter/getter objects from struct schema\n// ---------------------------------------------------------------------------\n\nfunction buildSetters(\n  raw: DirtyUniformBuffer,\n  schema: TapezStruct\n): Record<string, (value: unknown) => void> {\n  const setters: Record<string, (value: unknown) => void> = {}\n  for (const field of schema.layout.fields) {\n    setters[field.name] = createSetter(raw, field)\n  }\n  return setters\n}\n\nfunction buildGetters(\n  raw: DirtyUniformBuffer,\n  schema: TapezStruct\n): Record<string, () => unknown> {\n  const getters: Record<string, () => unknown> = {}\n  for (const field of schema.layout.fields) {\n    getters[field.name] = createGetter(raw, field)\n  }\n  return getters\n}\n\nfunction createSetter(\n  raw: DirtyUniformBuffer,\n  field: FieldLayout\n): (value: unknown) => void {\n  const type = field.type\n  const byteOffset = field.offset\n\n  switch (type.kind) {\n    case 'scalar':\n    case 'atomic': {\n      const index = byteOffset / 4\n      const arrayKind = type.kind === 'atomic'\n        ? (type as TapezAtomic).arrayKind\n        : (type as TapezScalar).arrayKind\n      switch (arrayKind) {\n        case 'f32':\n          return (v) => raw.setF32(index, v as number)\n        case 'u32':\n          return (v) => raw.setU32(index, v as number)\n        case 'i32':\n          return (v) => raw.setI32(index, v as number)\n      }\n      break\n    }\n\n    case 'vector': {\n      const vec = type as TapezVector\n      const startIndex = byteOffset / 4\n      const count = vec.components\n      const arrayKind = vec.componentType.arrayKind\n      switch (arrayKind) {\n        case 'f32':\n          return (v) => {\n            const arr = v as number[] | Float32Array\n            for (let i = 0; i < count; i++) raw.setF32(startIndex + i, arr[i]!)\n          }\n        case 'u32':\n          return (v) => {\n            const arr = v as number[] | Uint32Array\n            for (let i = 0; i < count; i++) raw.setU32(startIndex + i, arr[i]!)\n          }\n        case 'i32':\n          return (v) => {\n            const arr = v as number[] | Int32Array\n            for (let i = 0; i < count; i++) raw.setI32(startIndex + i, arr[i]!)\n          }\n      }\n      break\n    }\n\n    case 'matrix': {\n      const startIndex = byteOffset / 4\n      const floatCount = type.byteSize / 4\n      return (v) => {\n        const arr = v as number[] | Float32Array\n        for (let i = 0; i < floatCount; i++) raw.setF32(startIndex + i, arr[i]!)\n      }\n    }\n\n    default:\n      return () => { /* no-op */ }\n  }\n}\n\nfunction createGetter(\n  raw: DirtyUniformBuffer,\n  field: FieldLayout\n): () => unknown {\n  const type = field.type\n  const byteOffset = field.offset\n\n  switch (type.kind) {\n    case 'scalar':\n    case 'atomic': {\n      const index = byteOffset / 4\n      const arrayKind = type.kind === 'atomic'\n        ? (type as TapezAtomic).arrayKind\n        : (type as TapezScalar).arrayKind\n      switch (arrayKind) {\n        case 'f32':\n          return () => raw.f32[index]\n        case 'u32':\n          return () => raw.u32[index]\n        case 'i32':\n          return () => raw.i32[index]\n      }\n      break\n    }\n\n    case 'vector': {\n      const vec = type as TapezVector\n      const startIndex = byteOffset / 4\n      const count = vec.components\n      const arrayKind = vec.componentType.arrayKind\n      switch (arrayKind) {\n        case 'f32':\n          return () => Array.from(raw.f32.subarray(startIndex, startIndex + count))\n        case 'u32':\n          return () => Array.from(raw.u32.subarray(startIndex, startIndex + count))\n        case 'i32':\n          return () => Array.from(raw.i32.subarray(startIndex, startIndex + count))\n      }\n      break\n    }\n\n    case 'matrix': {\n      const startIndex = byteOffset / 4\n      const floatCount = type.byteSize / 4\n      return () => Array.from(raw.f32.subarray(startIndex, startIndex + floatCount))\n    }\n\n    default:\n      return () => undefined\n  }\n}\n","/**\n * Bind group layout/entry helpers for TypedBuffer.\n *\n * Reduces boilerplate when creating bind group layouts and bind groups\n * from typed buffers.\n *\n * Usage:\n *   const layout = device.createBindGroupLayout({\n *     entries: [\n *       uniformEntry(0, GPUShaderStage.COMPUTE),\n *       storageEntry(1, GPUShaderStage.COMPUTE, 'read-only-storage'),\n *     ]\n *   })\n *\n *   const bindGroup = device.createBindGroup({\n *     layout,\n *     entries: [\n *       bufferEntry(0, configBuf),\n *       bufferEntry(1, stateBuf),\n *     ]\n *   })\n */\n\nimport type { TypedBufferBase } from './typed-buffer'\n\n/**\n * Create a bind group layout entry for a uniform buffer.\n */\nexport function uniformEntry(\n  binding: number,\n  visibility: GPUShaderStageFlags\n): GPUBindGroupLayoutEntry {\n  return { binding, visibility, buffer: { type: 'uniform' } }\n}\n\n/**\n * Create a bind group layout entry for a storage buffer.\n */\nexport function storageEntry(\n  binding: number,\n  visibility: GPUShaderStageFlags,\n  type: 'storage' | 'read-only-storage' = 'storage'\n): GPUBindGroupLayoutEntry {\n  return { binding, visibility, buffer: { type } }\n}\n\n/**\n * Create a bind group entry from a TypedBuffer or raw GPUBuffer.\n */\nexport function bufferEntry(binding: number, buf: TypedBufferBase | GPUBuffer): GPUBindGroupEntry {\n  const gpuBuffer = 'buffer' in buf && typeof (buf as TypedBufferBase).byteSize === 'number'\n    ? (buf as TypedBufferBase).buffer\n    : buf as GPUBuffer\n  return { binding, resource: { buffer: gpuBuffer } }\n}\n"],"mappings":"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","names":["struct","vec"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tapez/core",
-  "version": "0.0.0-alpha.2",
+  "version": "0.0.0-alpha.4",
   "description": "Typed GPU schema system for WebGPU",
   "license": "Apache-2.0",
   "type": "module",
@@ -18,15 +18,17 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
-    "dev": "tsc -p tsconfig.build.json --watch",
+    "build": "tsup src/index.ts --format esm --dts --sourcemap --clean",
+    "dev": "tsup src/index.ts --format esm --dts --sourcemap --watch",
+    "typecheck": "tsc --noEmit",
     "clean": "rm -rf dist"
   },
   "devDependencies": {
     "@webgpu/types": "^0.1.69",
-    "typescript": "^6.0.2"
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
   },
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/dist/array.d.ts

@@ -1,26 +0,0 @@
-/**
- * TapeZ array type — fixed-size GPU arrays.
- *
- * WGSL array layout:
- *   Element stride = roundUp(alignment, sizeof(element))
- *   Array size     = count * stride
- *   Array alignment = element alignment
- */
-import type { TapezType } from './types';
-export interface TapezArray extends TapezType {
-    readonly kind: 'array';
-    /** Element type */
-    readonly elementType: TapezType;
-    /** Number of elements */
-    readonly count: number;
-    /** Byte stride between consecutive elements (includes padding) */
-    readonly stride: number;
-}
-/**
- * Define a fixed-size GPU array.
- *
- * Element stride follows WGSL array layout rules:
- * stride = roundUp(element.alignment, element.byteSize)
- */
-export declare function arrayOf(elementType: TapezType, count: number): TapezArray;
-//# sourceMappingURL=array.d.ts.map

package/dist/array.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../src/array.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAOxC,MAAM,WAAW,UAAW,SAAQ,SAAS;IAC3C,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,mBAAmB;IACnB,QAAQ,CAAC,WAAW,EAAE,SAAS,CAAA;IAC/B,yBAAyB;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,kEAAkE;IAClE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,WAAW,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,UAAU,CAczE"}

package/dist/array.js

@@ -1,30 +0,0 @@
-/**
- * TapeZ array type — fixed-size GPU arrays.
- *
- * WGSL array layout:
- *   Element stride = roundUp(alignment, sizeof(element))
- *   Array size     = count * stride
- *   Array alignment = element alignment
- */
-import { roundUp } from './layout';
-/**
- * Define a fixed-size GPU array.
- *
- * Element stride follows WGSL array layout rules:
- * stride = roundUp(element.alignment, element.byteSize)
- */
-export function arrayOf(elementType, count) {
-    const stride = roundUp(elementType.alignment, elementType.byteSize);
-    const byteSize = count * stride;
-    const alignment = elementType.alignment;
-    return Object.freeze({
-        kind: 'array',
-        wgslType: `array<${elementType.wgslType}, ${count}>`,
-        byteSize,
-        alignment,
-        elementType,
-        count,
-        stride
-    });
-}
-//# sourceMappingURL=array.js.map

package/dist/array.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"array.js","sourceRoot":"","sources":["../src/array.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAgBlC;;;;;GAKG;AACH,MAAM,UAAU,OAAO,CAAC,WAAsB,EAAE,KAAa;IAC3D,MAAM,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,SAAS,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAA;IACnE,MAAM,QAAQ,GAAG,KAAK,GAAG,MAAM,CAAA;IAC/B,MAAM,SAAS,GAAG,WAAW,CAAC,SAAS,CAAA;IAEvC,OAAO,MAAM,CAAC,MAAM,CAAC;QACnB,IAAI,EAAE,OAAO;QACb,QAAQ,EAAE,SAAS,WAAW,CAAC,QAAQ,KAAK,KAAK,GAAG;QACpD,QAAQ;QACR,SAAS;QACT,WAAW;QACX,KAAK;QACL,MAAM;KACP,CAAC,CAAA;AACJ,CAAC"}

package/dist/bind-helpers.d.ts

@@ -1,36 +0,0 @@
-/**
- * Bind group layout/entry helpers for TypedBuffer.
- *
- * Reduces boilerplate when creating bind group layouts and bind groups
- * from typed buffers.
- *
- * Usage:
- *   const layout = device.createBindGroupLayout({
- *     entries: [
- *       uniformEntry(0, GPUShaderStage.COMPUTE),
- *       storageEntry(1, GPUShaderStage.COMPUTE, 'read-only-storage'),
- *     ]
- *   })
- *
- *   const bindGroup = device.createBindGroup({
- *     layout,
- *     entries: [
- *       bufferEntry(0, configBuf),
- *       bufferEntry(1, stateBuf),
- *     ]
- *   })
- */
-import type { TypedBufferBase } from './typed-buffer';
-/**
- * Create a bind group layout entry for a uniform buffer.
- */
-export declare function uniformEntry(binding: number, visibility: GPUShaderStageFlags): GPUBindGroupLayoutEntry;
-/**
- * Create a bind group layout entry for a storage buffer.
- */
-export declare function storageEntry(binding: number, visibility: GPUShaderStageFlags, type?: 'storage' | 'read-only-storage'): GPUBindGroupLayoutEntry;
-/**
- * Create a bind group entry from a TypedBuffer or raw GPUBuffer.
- */
-export declare function bufferEntry(binding: number, buf: TypedBufferBase | GPUBuffer): GPUBindGroupEntry;
-//# sourceMappingURL=bind-helpers.d.ts.map

package/dist/bind-helpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bind-helpers.d.ts","sourceRoot":"","sources":["../src/bind-helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAErD;;GAEG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,mBAAmB,GAC9B,uBAAuB,CAEzB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,mBAAmB,EAC/B,IAAI,GAAE,SAAS,GAAG,mBAA+B,GAChD,uBAAuB,CAEzB;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,eAAe,GAAG,SAAS,GAAG,iBAAiB,CAKhG"}

package/dist/bind-helpers.js

@@ -1,44 +0,0 @@
-/**
- * Bind group layout/entry helpers for TypedBuffer.
- *
- * Reduces boilerplate when creating bind group layouts and bind groups
- * from typed buffers.
- *
- * Usage:
- *   const layout = device.createBindGroupLayout({
- *     entries: [
- *       uniformEntry(0, GPUShaderStage.COMPUTE),
- *       storageEntry(1, GPUShaderStage.COMPUTE, 'read-only-storage'),
- *     ]
- *   })
- *
- *   const bindGroup = device.createBindGroup({
- *     layout,
- *     entries: [
- *       bufferEntry(0, configBuf),
- *       bufferEntry(1, stateBuf),
- *     ]
- *   })
- */
-/**
- * Create a bind group layout entry for a uniform buffer.
- */
-export function uniformEntry(binding, visibility) {
-    return { binding, visibility, buffer: { type: 'uniform' } };
-}
-/**
- * Create a bind group layout entry for a storage buffer.
- */
-export function storageEntry(binding, visibility, type = 'storage') {
-    return { binding, visibility, buffer: { type } };
-}
-/**
- * Create a bind group entry from a TypedBuffer or raw GPUBuffer.
- */
-export function bufferEntry(binding, buf) {
-    const gpuBuffer = 'buffer' in buf && typeof buf.byteSize === 'number'
-        ? buf.buffer
-        : buf;
-    return { binding, resource: { buffer: gpuBuffer } };
-}
-//# sourceMappingURL=bind-helpers.js.map

package/dist/bind-helpers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"bind-helpers.js","sourceRoot":"","sources":["../src/bind-helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH;;GAEG;AACH,MAAM,UAAU,YAAY,CAC1B,OAAe,EACf,UAA+B;IAE/B,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE,CAAA;AAC7D,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,YAAY,CAC1B,OAAe,EACf,UAA+B,EAC/B,OAAwC,SAAS;IAEjD,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,EAAE,CAAA;AAClD,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,WAAW,CAAC,OAAe,EAAE,GAAgC;IAC3E,MAAM,SAAS,GAAG,QAAQ,IAAI,GAAG,IAAI,OAAQ,GAAuB,CAAC,QAAQ,KAAK,QAAQ;QACxF,CAAC,CAAE,GAAuB,CAAC,MAAM;QACjC,CAAC,CAAC,GAAgB,CAAA;IACpB,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,CAAA;AACrD,CAAC"}

package/dist/const.d.ts

@@ -1,26 +0,0 @@
-/**
- * TapeZ constants — shared between TypeScript and WGSL.
- *
- * Usage:
- *   const MAX_ROWS = tapez.const('MAX_ROWS', tapez.u32, 4096)
- *
- *   MAX_ROWS.value     // 4096 (use in TypeScript)
- *   MAX_ROWS.toWGSL()  // 'const MAX_ROWS: u32 = 4096u;' (injected into WGSL)
- */
-import type { TapezScalar } from './types';
-export interface TapezConst<T extends TapezScalar = TapezScalar> {
-    readonly kind: 'const';
-    /** Constant name (used in both TS and WGSL) */
-    readonly name: string;
-    /** Scalar type */
-    readonly type: T;
-    /** The value */
-    readonly value: number;
-    /** Generate WGSL const declaration */
-    toWGSL(): string;
-}
-/**
- * Define a shared constant available in both TypeScript and WGSL.
- */
-export declare function constant<T extends TapezScalar>(name: string, type: T, value: number): TapezConst<T>;
-//# sourceMappingURL=const.d.ts.map

package/dist/const.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"const.d.ts","sourceRoot":"","sources":["../src/const.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAM1C,MAAM,WAAW,UAAU,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW;IAC7D,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,+CAA+C;IAC/C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,kBAAkB;IAClB,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAA;IAChB,gBAAgB;IAChB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,sCAAsC;IACtC,MAAM,IAAI,MAAM,CAAA;CACjB;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,WAAW,EAC5C,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,CAAC,EACP,KAAK,EAAE,MAAM,GACZ,UAAU,CAAC,CAAC,CAAC,CAUf"}

package/dist/const.js

@@ -1,43 +0,0 @@
-/**
- * TapeZ constants — shared between TypeScript and WGSL.
- *
- * Usage:
- *   const MAX_ROWS = tapez.const('MAX_ROWS', tapez.u32, 4096)
- *
- *   MAX_ROWS.value     // 4096 (use in TypeScript)
- *   MAX_ROWS.toWGSL()  // 'const MAX_ROWS: u32 = 4096u;' (injected into WGSL)
- */
-/**
- * Define a shared constant available in both TypeScript and WGSL.
- */
-export function constant(name, type, value) {
-    return Object.freeze({
-        kind: 'const',
-        name,
-        type,
-        value,
-        toWGSL() {
-            return constToWGSL(name, type, value);
-        }
-    });
-}
-// ---------------------------------------------------------------------------
-// WGSL emission
-// ---------------------------------------------------------------------------
-function constToWGSL(name, type, value) {
-    let literal;
-    switch (type.arrayKind) {
-        case 'f32':
-            // Ensure float literal has a decimal point
-            literal = Number.isInteger(value) ? `${value}.0` : `${value}`;
-            break;
-        case 'u32':
-            literal = `${value >>> 0}u`;
-            break;
-        case 'i32':
-            literal = `${value | 0}i`;
-            break;
-    }
-    return `const ${name}: ${type.wgslType} = ${literal};`;
-}
-//# sourceMappingURL=const.js.map

package/dist/const.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"const.js","sourceRoot":"","sources":["../src/const.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAoBH;;GAEG;AACH,MAAM,UAAU,QAAQ,CACtB,IAAY,EACZ,IAAO,EACP,KAAa;IAEb,OAAO,MAAM,CAAC,MAAM,CAAC;QACnB,IAAI,EAAE,OAAO;QACb,IAAI;QACJ,IAAI;QACJ,KAAK;QACL,MAAM;YACJ,OAAO,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,CAAA;QACvC,CAAC;KACF,CAAC,CAAA;AACJ,CAAC;AAED,8EAA8E;AAC9E,gBAAgB;AAChB,8EAA8E;AAE9E,SAAS,WAAW,CAAC,IAAY,EAAE,IAAiB,EAAE,KAAa;IACjE,IAAI,OAAe,CAAA;IACnB,QAAQ,IAAI,CAAC,SAAS,EAAE,CAAC;QACvB,KAAK,KAAK;YACR,2CAA2C;YAC3C,OAAO,GAAG,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,IAAI,CAAC,CAAC,CAAC,GAAG,KAAK,EAAE,CAAA;YAC7D,MAAK;QACP,KAAK,KAAK;YACR,OAAO,GAAG,GAAG,KAAK,KAAK,CAAC,GAAG,CAAA;YAC3B,MAAK;QACP,KAAK,KAAK;YACR,OAAO,GAAG,GAAG,KAAK,GAAG,CAAC,GAAG,CAAA;YACzB,MAAK;IACT,CAAC;IACD,OAAO,SAAS,IAAI,KAAK,IAAI,CAAC,QAAQ,MAAM,OAAO,GAAG,CAAA;AACxD,CAAC"}

package/dist/gpu-buffer-utils.d.ts

@@ -1,40 +0,0 @@
-/** Static 16-byte ArrayBuffer containing [0, 0, 0, 0] for GPU buffer resets */
-export declare const ZERO_U32_4_BUFFER: ArrayBuffer;
-/** Static 16-byte ArrayBuffer containing [6, 0, 0, 0] for indirect draw buffer init */
-export declare const INDIRECT_INIT_6_BUFFER: ArrayBuffer;
-export declare function makeIndirectBuffer(device: GPUDevice, label: string, byteSize?: number): GPUBuffer;
-export declare function makeStorageBuffer(device: GPUDevice, label: string, byteSize: number, extraUsageFlags?: GPUBufferUsageFlags): GPUBuffer;
-export declare class UniformBuffer {
-    readonly buffer: GPUBuffer;
-    readonly scratch: ArrayBuffer;
-    readonly u32: Uint32Array;
-    readonly i32: Int32Array;
-    readonly f32: Float32Array;
-    readonly byteSize: number;
-    constructor(device: GPUDevice, label: string, byteSize: number, usage?: GPUBufferUsageFlags);
-    write(queue: GPUQueue, offsetBytes?: number): void;
-    destroy(): void;
-}
-/**
- * UniformBuffer with dirty tracking for conditional GPU uploads.
- * Use set* methods to write values - they only mark dirty if value changed.
- * Call writeIfDirty(queue) once per frame to upload if any values changed.
- *
- * Eliminates boilerplate "cache field + comparison + write" patterns in entities.
- */
-export declare class DirtyUniformBuffer extends UniformBuffer {
-    private _dirty;
-    /** Set a u32 value at index, marks dirty only if value changed */
-    setU32(i: number, v: number): void;
-    /** Set an i32 value at index, marks dirty only if value changed */
-    setI32(i: number, v: number): void;
-    /** Set an f32 value at index, marks dirty only if value changed */
-    setF32(i: number, v: number): void;
-    /** Force dirty state (use when external factors require re-upload) */
-    markDirty(): void;
-    /** Returns true if any values have changed since last write */
-    get isDirty(): boolean;
-    /** Upload to GPU only if dirty, then clear dirty flag */
-    writeIfDirty(queue: GPUQueue, offsetBytes?: number): void;
-}
-//# sourceMappingURL=gpu-buffer-utils.d.ts.map

package/dist/gpu-buffer-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"gpu-buffer-utils.d.ts","sourceRoot":"","sources":["../src/gpu-buffer-utils.ts"],"names":[],"mappings":"AAMA,+EAA+E;AAC/E,eAAO,MAAM,iBAAiB,aAAsB,CAAA;AAEpD,uFAAuF;AACvF,eAAO,MAAM,sBAAsB,aAAsB,CAAA;AAOzD,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,MAAM,EACb,QAAQ,SAAoC,GAC3C,SAAS,CAMX;AAED,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,eAAe,GAAE,mBAAuB,GACvC,SAAS,CAMX;AAED,qBAAa,aAAa;IACxB,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAA;IAC1B,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAA;IAC7B,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAA;IACzB,QAAQ,CAAC,GAAG,EAAE,UAAU,CAAA;IACxB,QAAQ,CAAC,GAAG,EAAE,YAAY,CAAA;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;gBAEb,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,mBAAmB;IAqB3F,KAAK,CAAC,KAAK,EAAE,QAAQ,EAAE,WAAW,SAAI,GAAG,IAAI;IAI7C,OAAO,IAAI,IAAI;CAGhB;AAED;;;;;;GAMG;AACH,qBAAa,kBAAmB,SAAQ,aAAa;IACnD,OAAO,CAAC,MAAM,CAAO;IAErB,kEAAkE;IAClE,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAOlC,mEAAmE;IACnE,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAOlC,mEAAmE;IACnE,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAOlC,sEAAsE;IACtE,SAAS,IAAI,IAAI;IAIjB,+DAA+D;IAC/D,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,yDAAyD;IACzD,YAAY,CAAC,KAAK,EAAE,QAAQ,EAAE,WAAW,SAAI,GAAG,IAAI;CAKrD"}

package/dist/gpu-buffer-utils.js

@@ -1,105 +0,0 @@
-const DEFAULT_INDIRECT_BUFFER_BYTE_SIZE = 16;
-// ============================================================================
-// Static Reset Constants (zero-allocation hot path resets)
-// ============================================================================
-/** Static 16-byte ArrayBuffer containing [0, 0, 0, 0] for GPU buffer resets */
-export const ZERO_U32_4_BUFFER = new ArrayBuffer(16); // ArrayBuffer is zero-initialized by spec
-/** Static 16-byte ArrayBuffer containing [6, 0, 0, 0] for indirect draw buffer init */
-export const INDIRECT_INIT_6_BUFFER = new ArrayBuffer(16);
-new Uint32Array(INDIRECT_INIT_6_BUFFER).set([6, 0, 0, 0]);
-// ============================================================================
-// Buffer Factory Functions
-// ============================================================================
-export function makeIndirectBuffer(device, label, byteSize = DEFAULT_INDIRECT_BUFFER_BYTE_SIZE) {
-    return device.createBuffer({
-        label,
-        size: byteSize,
-        usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
-    });
-}
-export function makeStorageBuffer(device, label, byteSize, extraUsageFlags = 0) {
-    return device.createBuffer({
-        label,
-        size: byteSize,
-        usage: GPUBufferUsage.STORAGE | extraUsageFlags
-    });
-}
-export class UniformBuffer {
-    buffer;
-    scratch;
-    u32;
-    i32;
-    f32;
-    byteSize;
-    constructor(device, label, byteSize, usage) {
-        if (byteSize <= 0) {
-            throw new Error(`UniformBuffer size must be positive, got ${byteSize}`);
-        }
-        if (byteSize % 4 !== 0) {
-            throw new Error(`UniformBuffer size must be 4-byte aligned, got ${byteSize}`);
-        }
-        this.byteSize = byteSize;
-        this.buffer = device.createBuffer({
-            label,
-            size: byteSize,
-            usage: usage ?? (GPUBufferUsage.UNIFORM | GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST)
-        });
-        this.scratch = new ArrayBuffer(byteSize);
-        this.u32 = new Uint32Array(this.scratch);
-        this.i32 = new Int32Array(this.scratch);
-        this.f32 = new Float32Array(this.scratch);
-    }
-    write(queue, offsetBytes = 0) {
-        queue.writeBuffer(this.buffer, offsetBytes, this.scratch);
-    }
-    destroy() {
-        this.buffer.destroy();
-    }
-}
-/**
- * UniformBuffer with dirty tracking for conditional GPU uploads.
- * Use set* methods to write values - they only mark dirty if value changed.
- * Call writeIfDirty(queue) once per frame to upload if any values changed.
- *
- * Eliminates boilerplate "cache field + comparison + write" patterns in entities.
- */
-export class DirtyUniformBuffer extends UniformBuffer {
-    _dirty = true;
-    /** Set a u32 value at index, marks dirty only if value changed */
-    setU32(i, v) {
-        if (this.u32[i] !== v) {
-            this.u32[i] = v;
-            this._dirty = true;
-        }
-    }
-    /** Set an i32 value at index, marks dirty only if value changed */
-    setI32(i, v) {
-        if (this.i32[i] !== v) {
-            this.i32[i] = v;
-            this._dirty = true;
-        }
-    }
-    /** Set an f32 value at index, marks dirty only if value changed */
-    setF32(i, v) {
-        if (this.f32[i] !== v) {
-            this.f32[i] = v;
-            this._dirty = true;
-        }
-    }
-    /** Force dirty state (use when external factors require re-upload) */
-    markDirty() {
-        this._dirty = true;
-    }
-    /** Returns true if any values have changed since last write */
-    get isDirty() {
-        return this._dirty;
-    }
-    /** Upload to GPU only if dirty, then clear dirty flag */
-    writeIfDirty(queue, offsetBytes = 0) {
-        if (!this._dirty)
-            return;
-        this.write(queue, offsetBytes);
-        this._dirty = false;
-    }
-}
-//# sourceMappingURL=gpu-buffer-utils.js.map

package/dist/gpu-buffer-utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"gpu-buffer-utils.js","sourceRoot":"","sources":["../src/gpu-buffer-utils.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAC/C,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAGlE,OAAO,EACL,KAAK,EACL,KAAK,EACL,KAAK,EACL,KAAK,EACL,KAAK,EACL,KAAK,EACL,KAAK,EACL,KAAK,EACL,KAAK,EACN,MAAM,WAAW,CAAA;AAClB,YAAY,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAG5C,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AACpD,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAG3C,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACjC,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAG3C,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AACjC,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAGzC,OAAO,EAAE,QAAQ,IAAI,KAAK,EAAE,MAAM,SAAS,CAAA;AAC3C,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAGzC,OAAO,EAAE,WAAW,EAAE,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAGlE,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAGxE,OAAO,EAAE,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAA;AACvD,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA"}

package/dist/layout.d.ts

@@ -1,36 +0,0 @@
-/**
- * WGSL struct layout computation — alignment, padding, field offsets.
- *
- * Implements the WGSL spec's struct layout algorithm:
- * https://www.w3.org/TR/WGSL/#structure-member-layout
- */
-import type { TapezType } from './types';
-/** Round `offset` up to the next multiple of `alignment`. */
-export declare function roundUp(alignment: number, offset: number): number;
-export interface FieldLayout {
-    /** Field name */
-    readonly name: string;
-    /** Field type */
-    readonly type: TapezType;
-    /** Byte offset from struct start */
-    readonly offset: number;
-}
-export interface StructLayout {
-    /** Ordered field layouts */
-    readonly fields: readonly FieldLayout[];
-    /** Total byte size (padded to struct alignment) */
-    readonly byteSize: number;
-    /** Struct alignment = max(field alignments) */
-    readonly alignment: number;
-    /** Map from field name to byte offset */
-    readonly offsets: Record<string, number>;
-}
-/**
- * Compute the byte layout of a struct given its fields in order.
- * Follows WGSL struct member layout rules.
- */
-export declare function computeStructLayout(fields: readonly {
-    name: string;
-    type: TapezType;
-}[]): StructLayout;
-//# sourceMappingURL=layout.d.ts.map

package/dist/layout.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"layout.d.ts","sourceRoot":"","sources":["../src/layout.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAMxC,6DAA6D;AAC7D,wBAAgB,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAEjE;AAMD,MAAM,WAAW,WAAW;IAC1B,iBAAiB;IACjB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,iBAAiB;IACjB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,oCAAoC;IACpC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAED,MAAM,WAAW,YAAY;IAC3B,4BAA4B;IAC5B,QAAQ,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,CAAA;IACvC,mDAAmD;IACnD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,+CAA+C;IAC/C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,yCAAyC;IACzC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACzC;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,SAAS,CAAA;CAAE,EAAE,GACnD,YAAY,CAyBd"}

package/dist/layout.js

@@ -1,39 +0,0 @@
-/**
- * WGSL struct layout computation — alignment, padding, field offsets.
- *
- * Implements the WGSL spec's struct layout algorithm:
- * https://www.w3.org/TR/WGSL/#structure-member-layout
- */
-// ---------------------------------------------------------------------------
-// Layout helpers
-// ---------------------------------------------------------------------------
-/** Round `offset` up to the next multiple of `alignment`. */
-export function roundUp(alignment, offset) {
-    return Math.ceil(offset / alignment) * alignment;
-}
-/**
- * Compute the byte layout of a struct given its fields in order.
- * Follows WGSL struct member layout rules.
- */
-export function computeStructLayout(fields) {
-    const layouts = [];
-    const offsets = {};
-    let offset = 0;
-    let maxAlignment = 1;
-    for (const { name, type } of fields) {
-        // Align the field
-        offset = roundUp(type.alignment, offset);
-        layouts.push({ name, type, offset });
-        offsets[name] = offset;
-        // Advance past this field
-        offset += type.byteSize;
-        // Track max alignment for struct alignment
-        if (type.alignment > maxAlignment) {
-            maxAlignment = type.alignment;
-        }
-    }
-    // Struct size is rounded up to struct alignment
-    const byteSize = roundUp(maxAlignment, offset);
-    return { fields: layouts, byteSize, alignment: maxAlignment, offsets };
-}
-//# sourceMappingURL=layout.js.map

package/dist/layout.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"layout.js","sourceRoot":"","sources":["../src/layout.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,8EAA8E;AAC9E,iBAAiB;AACjB,8EAA8E;AAE9E,6DAA6D;AAC7D,MAAM,UAAU,OAAO,CAAC,SAAiB,EAAE,MAAc;IACvD,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC,GAAG,SAAS,CAAA;AAClD,CAAC;AA0BD;;;GAGG;AACH,MAAM,UAAU,mBAAmB,CACjC,MAAoD;IAEpD,MAAM,OAAO,GAAkB,EAAE,CAAA;IACjC,MAAM,OAAO,GAA2B,EAAE,CAAA;IAC1C,IAAI,MAAM,GAAG,CAAC,CAAA;IACd,IAAI,YAAY,GAAG,CAAC,CAAA;IAEpB,KAAK,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,MAAM,EAAE,CAAC;QACpC,kBAAkB;QAClB,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,MAAM,CAAC,CAAA;QACxC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAA;QACpC,OAAO,CAAC,IAAI,CAAC,GAAG,MAAM,CAAA;QAEtB,0BAA0B;QAC1B,MAAM,IAAI,IAAI,CAAC,QAAQ,CAAA;QAEvB,2CAA2C;QAC3C,IAAI,IAAI,CAAC,SAAS,GAAG,YAAY,EAAE,CAAC;YAClC,YAAY,GAAG,IAAI,CAAC,SAAS,CAAA;QAC/B,CAAC;IACH,CAAC;IAED,gDAAgD;IAChD,MAAM,QAAQ,GAAG,OAAO,CAAC,YAAY,EAAE,MAAM,CAAC,CAAA;IAE9C,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,YAAY,EAAE,OAAO,EAAE,CAAA;AACxE,CAAC"}