@genai-fi/nanogpt 0.10.2 → 0.11.0

package/dist/{backend_util-B1XRLuq9.js → backend_util-C7NWHpv7.js}

@@ -1,11 +1,10 @@
-import { s as m, i as w, K as I, a as d, z as A, q as _ } from "./tensor-CzmOBsdf.js";
-import { d as y, f as M, h as T, c as b, e as D, a as L, b as x, g as W } from "./axis_util-BsIr9ZNu.js";
-import { j as v, h as F, q as N } from "./index-D6Q1lPZO.js";
-import { a as C, c as P } from "./concat_util-iBYIyuQe.js";
-import { S as z, a as q, b as B, c as U, d as j, e as G, f as H, g as V, h as Z, i as k, j as K, k as J, l as X, m as Y, s as Q, n as ee, t as te } from "./selu_util-BGPXmd4B.js";
-import { s as se } from "./slice_util-DyjSAD0u.js";
-import { a0 as ne, u as re, w as oe } from "./tensor_util-DfwaWayG.js";
-import { c as ae, v as ie, a as ue } from "./scatter_nd_util-C7zXRT_h.js";
+import { V as m, a9 as w, aU as I, y as d, ax as A, aB as _, $ as y, ad as M, a0 as T, aV as b, ak as D, aW as x } from "./index-D0RBWjq8.js";
+import { d as L, f as W, h as v, c as F, e as N, a as C, b as P, g as z } from "./axis_util-DofAuy0p.js";
+import { a as B, c as U } from "./concat_util-CHsJFZJJ.js";
+import { c as V, b as G, d as H, f as j, g as q, h as Z, i as k, j as J, k as K, m as X, t as Y } from "./step-dXR33iOg.js";
+import { S as Q, a as ee, b as te, g as se, c as ne, s as re } from "./selu_util-BuLbmbrl.js";
+import { s as oe } from "./slice_util-D8CQRenR.js";
+import { c as ae, v as ie, a as ue } from "./scatter_nd_util-BY22Cc-C.js";
 import { a as le, c as pe, b as ce, e as he, d as fe, g as ge, m as de, s as me } from "./complex_util-Yc1A_gV1.js";
 function Ee(e, t) {
   const r = e.shape.length, s = t.shape.length;
@@ -147,7 +146,7 @@ function Te(e, t, r) {
     s.push(e[n + 1] - t[n][0] - t[n][1]);
   return s;
 }
-const be = 0.3275911, De = 0.254829592, Le = -0.284496736, xe = 1.421413741, We = -1.453152027, ve = 1.061405429;
+const be = 0.3275911, De = 0.254829592, xe = -0.284496736, Le = 1.421413741, We = -1.453152027, ve = 1.061405429;
 const E = "->", Fe = /->/g, S = ",", R = "...";
 function Ne(e, t) {
   e = e.replace(/\s/g, "");
@@ -213,22 +212,22 @@ function ze(e, t) {
     s.push([]);
   const o = [];
   for (let a = 0; a < r.length; ++a) {
-    const u = r[a], p = Be(t, u);
+    const u = r[a], p = Ue(t, u);
     for (const c of p)
       o.indexOf(c) === -1 && (s[a].push(c), o.push(c));
   }
   return { path: r, steps: s };
 }
-function qe(e) {
+function Be(e) {
   return e.every((t, r) => t === r);
 }
-function Be(e, t) {
+function Ue(e, t) {
   const r = [];
   for (let s = 0; s < e.length; ++s)
     (e[s].length === 0 || e[s].indexOf(t) !== -1 || t === -1) && r.push(s);
   return r;
 }
-function Ue(e, t, r = 0) {
+function Ve(e, t, r = 0) {
   let s = [];
   if (typeof t == "number")
     d(e.shape[r] % t === 0, () => "Number of splits must evenly divide the axis."), s = new Array(t).fill(e.shape[r] / t);
@@ -244,17 +243,17 @@ function Ue(e, t, r = 0) {
   }
   return s;
 }
-function je(e) {
+function Ge(e) {
   return `Received SparseTensor with denseShape[0] = 0 but
   indices.shape[0] = ${e}`;
 }
-function Ge(e, t) {
+function He(e, t) {
   return `indices(${e}, 0) is invalid: ${t} < 0`;
 }
-function He(e, t, r) {
+function je(e, t, r) {
   return `indices(${e}, 0) is invalid: ${t} >= ${r}`;
 }
-function Ve(e, t) {
+function qe(e, t) {
   return `only one output dimension may be -1, not both ${e} and ${t}`;
 }
 function Ze(e, t) {
@@ -263,12 +262,12 @@ function Ze(e, t) {
 function ke() {
   return "reshape cannot infer the missing input size for an empty tensor unless all specified input sizes are non-zero";
 }
-function Ke(e, t) {
+function Je(e, t) {
   const r = m(e), s = m(t);
   return `Input to reshape is a SparseTensor with ${r}
   dense values, but the requested shape requires a multiple of ${s}. inputShape=${e} outputShape= ${t}`;
 }
-function Je(e, t) {
+function Ke(e, t) {
   const r = m(e), s = m(t);
   return `Input to reshape is a tensor with ${r} dense values, but the requested shape has ${s}. inputShape=${e} outputShape=${t}`;
 }
@@ -336,11 +335,11 @@ function ot(e) {
 function at(e) {
   return e.map((t) => _(t));
 }
-const mt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const dt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   ERF_A1: De,
-  ERF_A2: Le,
-  ERF_A3: xe,
+  ERF_A2: xe,
+  ERF_A3: Le,
   ERF_A4: We,
   ERF_A5: ve,
   ERF_P: be,
@@ -348,84 +347,84 @@ const mt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   get RowPartitionType() {
     return f;
   },
-  SELU_SCALE: z,
-  SELU_SCALEALPHA: q,
-  applyActivation: B,
-  assertAndGetBroadcastShape: v,
-  assertAxesAreInnerMostDims: y,
-  assertParamsConsistent: C,
+  SELU_SCALE: Q,
+  SELU_SCALEALPHA: ee,
+  applyActivation: te,
+  assertAndGetBroadcastShape: y,
+  assertAxesAreInnerMostDims: L,
+  assertParamsConsistent: B,
   assignToTypedArray: le,
-  axesAreInnerMostDims: M,
+  axesAreInnerMostDims: W,
   calculateShapes: ae,
   checkEinsumDimSizes: Pe,
-  checkPadOnDimRoundingMode: U,
-  combineLocations: T,
+  checkPadOnDimRoundingMode: V,
+  combineLocations: v,
   combineRaggedTensorToTensorShapes: Ie,
   complexWithEvenIndex: pe,
   complexWithOddIndex: ce,
-  computeConv2DInfo: j,
-  computeConv3DInfo: G,
-  computeDefaultPad: H,
-  computeDilation2DInfo: V,
+  computeConv2DInfo: G,
+  computeConv3DInfo: H,
+  computeDefaultPad: j,
+  computeDilation2DInfo: q,
   computeOptimalWindowSize: Oe,
-  computeOutAndReduceShapes: b,
-  computeOutShape: P,
+  computeOutAndReduceShapes: F,
+  computeOutShape: U,
   computePool2DInfo: Z,
   computePool3DInfo: k,
-  convertConv2DDataFormat: K,
+  convertConv2DDataFormat: J,
   decodeEinsumEquation: Ne,
-  eitherStridesOrDilationsAreOne: J,
-  expandShapeToKeepDim: D,
+  eitherStridesOrDilationsAreOne: K,
+  expandShapeToKeepDim: N,
   exponent: he,
   exponents: fe,
   fromStringArrayToUint8: at,
   fromUint8ToStringArray: ot,
-  getAxesPermutation: L,
-  getBroadcastDims: F,
+  getAxesPermutation: C,
+  getBroadcastDims: M,
   getComplexWithIndex: ge,
   getEinsumComputePath: ze,
   getEinsumPermutation: Ce,
-  getFusedBiasGradient: X,
-  getFusedDyActivation: Y,
+  getFusedBiasGradient: se,
+  getFusedDyActivation: ne,
   getImageCenter: we,
-  getInnerMostAxes: x,
+  getInnerMostAxes: P,
   getPermuted: _e,
   getRaggedRank: Se,
-  getReductionAxes: N,
+  getReductionAxes: T,
   getReshaped: Ae,
   getReshapedPermuted: ye,
   getRowPartitionTypesHelper: $e,
   getSliceBeginCoords: Me,
   getSliceSize: Te,
-  getSparseFillEmptyRowsIndicesDenseShapeMismatch: je,
-  getSparseFillEmptyRowsNegativeIndexErrorMessage: Ge,
-  getSparseFillEmptyRowsOutOfRangeIndexErrorMessage: He,
+  getSparseFillEmptyRowsIndicesDenseShapeMismatch: Ge,
+  getSparseFillEmptyRowsNegativeIndexErrorMessage: He,
+  getSparseFillEmptyRowsOutOfRangeIndexErrorMessage: je,
   getSparseReshapeEmptyTensorZeroOutputDimErrorMessage: ke,
-  getSparseReshapeInputOutputMismatchErrorMessage: Je,
-  getSparseReshapeInputOutputMultipleErrorMessage: Ke,
-  getSparseReshapeMultipleNegativeOneOutputDimErrorMessage: Ve,
+  getSparseReshapeInputOutputMismatchErrorMessage: Ke,
+  getSparseReshapeInputOutputMultipleErrorMessage: Je,
+  getSparseReshapeMultipleNegativeOneOutputDimErrorMessage: qe,
   getSparseReshapeNegativeOutputDimErrorMessage: Ze,
   getSparseSegmentReductionIndicesOutOfRangeErrorMessage: et,
   getSparseSegmentReductionNegativeSegmentIdsErrorMessage: Xe,
   getSparseSegmentReductionNonIncreasingSegmentIdsErrorMessage: Ye,
   getSparseSegmentReductionSegmentIdOutOfRangeErrorMessage: Qe,
-  getUndoAxesPermutation: W,
-  isIdentityPermutation: qe,
-  log: ne,
+  getUndoAxesPermutation: z,
+  isIdentityPermutation: Be,
+  log: b,
   mergeRealAndImagArrays: de,
   prepareAndValidate: Ee,
-  prepareSplitSize: Ue,
+  prepareSplitSize: Ve,
   segment_util: rt,
-  shouldFuse: Q,
-  slice_util: se,
+  shouldFuse: re,
+  slice_util: oe,
   splitRealAndImagArrays: me,
-  stridesOrDilationsArePositive: ee,
-  tupleValuesAreOne: te,
-  upcastType: re,
+  stridesOrDilationsArePositive: X,
+  tupleValuesAreOne: Y,
+  upcastType: D,
   validateDefaultValueShape: Re,
   validateInput: ie,
   validateUpdateShape: ue,
-  warn: oe
+  warn: x
 }, Symbol.toStringTag, { value: "Module" }));
 export {
   _e as A,
@@ -437,37 +436,37 @@ export {
   Pe as G,
   ze as H,
   Ce as I,
-  qe as J,
+  Be as J,
   Ee as K,
   nt as L,
   we as M,
-  Ue as N,
+  Ve as N,
   st as O,
   tt as P,
   f as R,
   Se as a,
-  mt as b,
+  dt as b,
   Oe as c,
   Ie as d,
   at as e,
   ot as f,
   $e as g,
-  je as h,
-  Ge as i,
-  He as j,
-  Ve as k,
+  Ge as h,
+  He as i,
+  je as j,
+  qe as k,
   Ze as l,
   ke as m,
-  Ke as n,
-  Je as o,
+  Je as n,
+  Ke as o,
   Xe as p,
   Ye as q,
   Qe as r,
   et as s,
   De as t,
-  Le as u,
+  xe as u,
   Re as v,
-  xe as w,
+  Le as w,
   We as x,
   ve as y,
   Ae as z

package/dist/{backend_webgpu-CqpfEImu.js → backend_webgpu-B0Vls736.js}

@@ -1,23 +1,21 @@
-import { e as D, J as W } from "./index-D6Q1lPZO.js";
-import { e as g, a as _, y as O, s as x, z as $, A as F, B as K, o as Z, q as j, g as X, i as q } from "./tensor-CzmOBsdf.js";
-import { m as J, f as ee, P as te } from "./webgpu_program-DzaQiqel.js";
-import { i as se, G as N } from "./webgpu_util-0_ubCEHJ.js";
-import { K as re, J as ne } from "./tensor_util-DfwaWayG.js";
-import { m as k } from "./complex_util-Yc1A_gV1.js";
-const l = g();
-l.registerFlag("WEBGPU_DEFERRED_SUBMIT_BATCH_SIZE", () => 15);
-l.registerFlag("WEBGPU_CPU_FORWARD", () => !0);
-l.registerFlag("WEBGPU_MATMUL_PROGRAM_TYPE", () => -1);
-l.registerFlag("WEBGPU_USE_NAIVE_CONV2D_TRANSPOSE", () => !0);
-l.registerFlag("WEBGPU_USE_LOW_POWER_GPU", () => !1);
-l.registerFlag("WEBGPU_CPU_HANDOFF_SIZE_THRESHOLD", () => 1e3);
-l.registerFlag("WEBGPU_USE_PROFILE_TOOL", () => !1);
-l.registerFlag("WEBGPU_IMPORT_EXTERNAL_TEXTURE", () => !0);
-l.registerFlag("WEBGPU_USE_NAIVE_CONV2D_DEBUG", () => !1);
-l.registerFlag("WEBGPU_THRESHOLD_TO_INCREASE_WORKGROUPS_FOR_MATMUL", () => -1);
-l.registerFlag("WEBGPU_CONV_SEPARATE_IM2COL_SHADER", () => !1);
-l.registerFlag("WEBGPU_PRINT_SHADER", () => "");
-l.registerFlag("WEBGPU_ENGINE_COMPILE_ONLY", () => !1);
+import { ab as g, au as $, av as K, e as D, y as _, aw as O, V as x, ax as Z, at as W, ay as F, az as j, aA as X, aB as J, ae as ee, a9 as k } from "./index-D0RBWjq8.js";
+import { m as te, f as se, P as re } from "./webgpu_program-CAE4RICo.js";
+import { i as ne, G as q } from "./webgpu_util-BdovYhXr.js";
+import { m as N } from "./complex_util-Yc1A_gV1.js";
+const d = g();
+d.registerFlag("WEBGPU_DEFERRED_SUBMIT_BATCH_SIZE", () => 15);
+d.registerFlag("WEBGPU_CPU_FORWARD", () => !0);
+d.registerFlag("WEBGPU_MATMUL_PROGRAM_TYPE", () => -1);
+d.registerFlag("WEBGPU_USE_NAIVE_CONV2D_TRANSPOSE", () => !0);
+d.registerFlag("WEBGPU_USE_LOW_POWER_GPU", () => !1);
+d.registerFlag("WEBGPU_CPU_HANDOFF_SIZE_THRESHOLD", () => 1e3);
+d.registerFlag("WEBGPU_USE_PROFILE_TOOL", () => !1);
+d.registerFlag("WEBGPU_IMPORT_EXTERNAL_TEXTURE", () => !0);
+d.registerFlag("WEBGPU_USE_NAIVE_CONV2D_DEBUG", () => !1);
+d.registerFlag("WEBGPU_THRESHOLD_TO_INCREASE_WORKGROUPS_FOR_MATMUL", () => -1);
+d.registerFlag("WEBGPU_CONV_SEPARATE_IM2COL_SHADER", () => !1);
+d.registerFlag("WEBGPU_PRINT_SHADER", () => "");
+d.registerFlag("WEBGPU_ENGINE_COMPILE_ONLY", () => !1);
 class ae {
   constructor(e) {
     e && (this.vendor = e.vendor, this.architecture = e.architecture, this.intelGPUGeneration = this.getIntelGPUGeneration());
@@ -70,8 +68,8 @@ class ie {
     }), this.freeBuffers = /* @__PURE__ */ new Map(), this.usedBuffers = /* @__PURE__ */ new Map(), this.numUsedBuffers = 0, this.numFreeBuffers = 0, this.numBytesUsed = 0, this.numBytesAllocated = 0;
   }
 }
-function z(d, e) {
-  return `${d}_${e}`;
+function z(l, e) {
+  return `${l}_${e}`;
 }
 class oe {
   constructor(e) {
@@ -122,30 +120,30 @@ class oe {
     }), this.freeTextures = /* @__PURE__ */ new Map(), this.usedTextures = /* @__PURE__ */ new Map(), this.numUsedTextures = 0, this.numFreeTextures = 0, this.numBytesUsed = 0, this.numBytesAllocated = 0;
   }
 }
-function L(d, e, t, s) {
-  return `${d}_${e}_${t}_${s}`;
+function L(l, e, t, s) {
+  return `${l}_${e}_${t}_${s}`;
 }
-function Q(d) {
-  if (d === "rgba8unorm")
+function Q(l) {
+  if (l === "rgba8unorm")
     return 16;
-  throw new Error(`${d} is not supported!`);
+  throw new Error(`${l} is not supported!`);
 }
-const ue = g().getNumber("WEBGPU_CPU_HANDOFF_SIZE_THRESHOLD"), fe = (d, e) => {
-  const t = d.limits.maxComputeWorkgroupsPerDimension, s = e.dispatchLayout, n = e.dispatch;
+const ue = g().getNumber("WEBGPU_CPU_HANDOFF_SIZE_THRESHOLD"), fe = (l, e) => {
+  const t = l.limits.maxComputeWorkgroupsPerDimension, s = e.dispatchLayout, n = e.dispatch;
   if (n.every((a) => a <= t))
     return n;
   _(n[0] > t && s.y === void 0 && s.z === void 0, () => "Dispatch size exceeds WebGPU limits in Y or Z dimension.");
   let r = Math.ceil(Math.sqrt(n[0]));
   return r > t ? (r = Math.ceil(Math.cbrt(n[0])), _(r <= t, () => "Total dispatch size exceeds WebGPU maximum."), [r, r, r]) : [r, r, 1];
 };
-class R extends re {
+class R extends $ {
   nextDataId() {
     return R.nextDataId++;
   }
   constructor(e, t) {
-    if (super(), this.commandQueueOwnedIds = /* @__PURE__ */ new WeakSet(), this.dispatchCountInPass = 0, this.disposed = !1, this.downloadWaitMs = 0, this.tensorDataPendingDisposal = [], this.queryResolveBuffer = null, this.querySet = null, this.querySetCount = 2, this.stagingPendingDisposal = [], this.uniformPendingDisposal = [], this.uploadWaitMs = 0, this.hasReadSyncWarned = !1, this.hasTimestampQueryWarned = !1, !se())
+    if (super(), this.commandQueueOwnedIds = /* @__PURE__ */ new WeakSet(), this.dispatchCountInPass = 0, this.disposed = !1, this.downloadWaitMs = 0, this.tensorDataPendingDisposal = [], this.queryResolveBuffer = null, this.querySet = null, this.querySetCount = 2, this.stagingPendingDisposal = [], this.uniformPendingDisposal = [], this.uploadWaitMs = 0, this.hasReadSyncWarned = !1, this.hasTimestampQueryWarned = !1, !ne())
       throw new Error("WebGPU is not supported on this device");
-    this.pipelineCache = {}, this.device = e, this.queue = e.queue, this.commandEncoder = null, this.computePassEncoder = null, this.adapterInfo = new ae(t), this.supportTimestampQuery = this.device.features.has("timestamp-query"), this.thresholdToIncreaseWorkgroups = this.adapterInfo.intelGPUGeneration >= 12 ? 16 : 8, this.bufferManager = new ie(this.device), this.textureManager = new oe(this.device), this.tensorMap = new ne(this, D()), g().getBool("WEBGPU_USE_PROFILE_TOOL") && (this.dummyCanvas = document.createElement("canvas"), this.dummyCanvas.width = 1, this.dummyCanvas.height = 1, this.dummyContext = this.dummyCanvas.getContext("webgpu"), this.dummyContext.configure({
+    this.pipelineCache = {}, this.device = e, this.queue = e.queue, this.commandEncoder = null, this.computePassEncoder = null, this.adapterInfo = new ae(t), this.supportTimestampQuery = this.device.features.has("timestamp-query"), this.thresholdToIncreaseWorkgroups = this.adapterInfo.intelGPUGeneration >= 12 ? 16 : 8, this.bufferManager = new ie(this.device), this.textureManager = new oe(this.device), this.tensorMap = new K(this, D()), g().getBool("WEBGPU_USE_PROFILE_TOOL") && (this.dummyCanvas = document.createElement("canvas"), this.dummyCanvas.width = 1, this.dummyCanvas.height = 1, this.dummyContext = this.dummyCanvas.getContext("webgpu"), this.dummyContext.configure({
       device: e,
       format: "bgra8unorm"
     }), document.body.appendChild(this.dummyCanvas));
@@ -250,7 +248,7 @@ class R extends re {
     if (s != null || t.dtype === "string")
       return s;
     if (t.dtype === "complex64") {
-      const E = this.readSync(n.real.dataId), B = this.readSync(n.imag.dataId), y = O(k(E, B).buffer, "float32");
+      const E = this.readSync(n.real.dataId), B = this.readSync(n.imag.dataId), y = O(N(E, B).buffer, "float32");
       return this.convertAndCacheOnCPU(e, y), y;
     }
     this.hasReadSyncWarned || (this.hasReadSyncWarned = !0, console.warn("The performance of synchronously reading data from GPU to CPU is poor on the webgpu backend, please use asynchronous APIs instead."));
@@ -266,7 +264,7 @@ class R extends re {
         alphaMode: r[B]
       }), y.getCurrentTexture();
     }).map((E, B) => {
-      const y = f * 4, b = (P, S, v) => {
+      const y = f * 4, G = (P, S, v) => {
         this.ensureCommandEncoderReady(), this.commandEncoder.copyBufferToTexture({
           buffer: a,
           bytesPerRow: y,
@@ -281,20 +279,20 @@ class R extends re {
           willReadFrequently: !0
         });
         I.clearRect(0, 0, P, S), I.drawImage(h[B], 0, 0);
-        const G = I.getImageData(0, 0, P, S).data, H = r[B], M = new Uint8ClampedArray(o, v, P * S * 4);
+        const b = I.getImageData(0, 0, P, S).data, H = r[B], M = new Uint8ClampedArray(o, v, P * S * 4);
         for (let p = 0; p < M.length; p += 4)
           if (H === "premultiplied")
-            M[p + 3] = G[p + 3];
+            M[p + 3] = b[p + 3];
           else {
-            const V = G[p];
-            M[p] = G[p + 2], M[p + 1] = G[p + 1], M[p + 2] = V;
+            const V = b[p];
+            M[p] = b[p + 2], M[p + 1] = b[p + 1], M[p + 2] = V;
           }
       }, Y = Math.floor(u / (f * c));
       let T = f, U = c, C = 0;
       for (let P = 0; P < Y; P++)
-        b(T, U, C), C += f * c * 4;
+        G(T, U, C), C += f * c * 4;
       const A = u % (f * c);
-      U = Math.floor(A / f), U > 0 && (b(T, U, C), C += U * (f * 4)), T = A % f, T > 0 && b(T, 1, C);
+      U = Math.floor(A / f), U > 0 && (G(T, U, C), C += U * (f * 4)), T = A % f, T > 0 && G(T, 1, C);
     });
     const w = O(o, t.dtype);
     return this.convertAndCacheOnCPU(e, w), w;
@@ -311,7 +309,7 @@ class R extends re {
         this.read(t.complexTensorInfos.real.dataId),
         this.read(t.complexTensorInfos.imag.dataId)
       ]), a = r[0], i = r[1];
-      n = k(a, i);
+      n = N(a, i);
     } else {
       const r = await this.getBufferData(t.resource);
       n = O(r, t.dtype);
@@ -339,7 +337,7 @@ class R extends re {
       refCount: 1,
       external: e.zeroCopy
     });
-    const a = this.tensorMap.get(r), i = N(a.dtype) * x(a.shape);
+    const a = this.tensorMap.get(r), i = q(a.dtype) * x(a.shape);
     if (e.buffer.size < i)
       throw new Error(`GPUBuffer size(${e.buffer.size}) is smaller than tensor size(${i})!`);
     if ((e.buffer.usage & (GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC)) !== (GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC))
@@ -365,7 +363,7 @@ class R extends re {
     const t = this.readSync(e.dataId);
     if (e.dtype === "string")
       try {
-        const s = t.map((n) => $(n));
+        const s = t.map((n) => Z(n));
         return W(e.shape, e.dtype, s);
       } catch {
         throw new Error("Failed to decode encoded string bytes into utf-8");
@@ -385,10 +383,10 @@ class R extends re {
       kernelMs: null,
       wallMs: null
     }, u = await Promise.all(r);
-    return i.kernelMs = K(u), i.getExtraProfileInfo = () => u.map((o, f) => ({ name: a[f], ms: o })).map((o) => `${o.name}: ${o.ms}`).join(", "), this.uploadWaitMs = 0, this.downloadWaitMs = 0, i;
+    return i.kernelMs = j(u), i.getExtraProfileInfo = () => u.map((o, f) => ({ name: a[f], ms: o })).map((o) => `${o.name}: ${o.ms}`).join(", "), this.uploadWaitMs = 0, this.downloadWaitMs = 0, i;
   }
   makeTensorInfo(e, t, s) {
-    return t === "string" && s != null && s.length > 0 && Z(s[0]) && (s = s.map((r) => j(r))), { dataId: this.write(s, e, t), shape: e, dtype: t };
+    return t === "string" && s != null && s.length > 0 && X(s[0]) && (s = s.map((r) => J(r))), { dataId: this.write(s, e, t), shape: e, dtype: t };
   }
   tensorToBinding(e) {
     if (!e)
@@ -400,16 +398,16 @@ class R extends re {
     const t = this.tensorMap.get(e);
     if (t.resource != null)
       return;
-    const s = N(t.dtype) * x(t.shape);
+    const s = q(t.dtype) * x(t.shape);
     let n;
     const r = GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST;
     if (t.values) {
       if (n = this.bufferManager.acquireBuffer(s, r, !0), n.mapState === "unmapped") {
         const a = this.bufferManager.acquireBuffer(s, GPUBufferUsage.MAP_WRITE | GPUBufferUsage.COPY_SRC, !0, !1), i = a.getMappedRange();
-        t.dtype === "int32" || t.dtype === "bool" ? new Int32Array(i).set(t.values) : new Float32Array(i).set(t.values), a.unmap(), this.ensureCommandEncoderReady(), this.endComputePassEncoder(), this.commandEncoder.copyBufferToBuffer(a, 0, n, 0, s), this.stagingPendingDisposal.push(a);
+        t.dtype === "int32" || t.dtype === "packedF16" || t.dtype === "bool" ? new Int32Array(i).set(t.values) : new Float32Array(i).set(t.values), a.unmap(), this.ensureCommandEncoderReady(), this.endComputePassEncoder(), this.commandEncoder.copyBufferToBuffer(a, 0, n, 0, s), this.stagingPendingDisposal.push(a);
       } else {
         const a = n.getMappedRange();
-        t.dtype === "int32" || t.dtype === "bool" ? new Int32Array(a).set(t.values) : new Float32Array(a).set(t.values), n.unmap();
+        t.dtype === "int32" || t.dtype === "packedF16" || t.dtype === "bool" ? new Int32Array(a).set(t.values) : new Float32Array(a).set(t.values), n.unmap();
       }
       t.values = null;
     } else
@@ -457,7 +455,7 @@ class R extends re {
   }
   runWebGPUProgram(e, t, s, n, r) {
     if (r || (r = this.makeTensorInfo(e.outputShape, s)), x(r.shape) === 0)
-      return this.tensorMap.get(r.dataId).values = X(r.dtype, 0), r;
+      return this.tensorMap.get(r.dataId).values = ee(r.dtype, 0), r;
     this.uploadToGPU(r.dataId), e.dispatch = fe(this.device, e);
     const a = t.map((u, o) => {
       if (u.dtype === "complex64")
@@ -470,9 +468,9 @@ class R extends re {
         name: e.variableNames[o]
       };
     });
-    e.shaderKey = J(e, a, r);
+    e.shaderKey = te(e, a, r);
     const i = g().getBool("WEBGPU_ENGINE_COMPILE_ONLY");
-    return e.shaderKey in this.pipelineCache || (this.pipelineCache[e.shaderKey] = ee(this.device, e, a, r, i)), e.pipeline = this.pipelineCache[e.shaderKey], i || this.recordAndSubmit(e, r, t, n), r;
+    return e.shaderKey in this.pipelineCache || (this.pipelineCache[e.shaderKey] = se(this.device, e, a, r, i)), e.pipeline = this.pipelineCache[e.shaderKey], i || this.recordAndSubmit(e, r, t, n), r;
   }
   recordAndSubmit(e, t, s, n) {
     if (e.pipeline instanceof Promise)
@@ -484,11 +482,11 @@ class R extends re {
       const h = "int32";
       a.map((m) => {
         r.push({ type: h, data: m });
-        const w = q(m);
+        const w = k(m);
         r.push({ type: h, data: w });
       });
     } else {
-      const h = q(t.shape);
+      const h = k(t.shape);
       r.push({ type: i, data: h });
     }
     if (e.size) {
@@ -520,7 +518,7 @@ class R extends re {
       querySet: this.querySet,
       beginningOfPassWriteIndex: 0,
       endOfPassWriteIndex: 1
-    }, this.computePassEncoder = this.commandEncoder.beginComputePass(c)) : this.computePassEncoder || (this.computePassEncoder = this.commandEncoder.beginComputePass(c)), this.computePassEncoder.setPipeline(e.pipeline), this.computePassEncoder.setBindGroup(0, o), this.computePassEncoder.dispatchWorkgroups(e.dispatch[0], e.dispatch[1], e.dispatch[2]), this.dispatchCountInPass++, (f || g().get("WEBGPU_DEFERRED_SUBMIT_BATCH_SIZE") <= this.dispatchCountInPass || e.pixelsOpType === te.DRAW) && (this.endComputePassEncoder(), f ? this.activeTimers.push({ name: e.constructor.name, query: this.getQueryTime() }) : this.submitQueue());
+    }, this.computePassEncoder = this.commandEncoder.beginComputePass(c)) : this.computePassEncoder || (this.computePassEncoder = this.commandEncoder.beginComputePass(c)), this.computePassEncoder.setPipeline(e.pipeline), this.computePassEncoder.setBindGroup(0, o), this.computePassEncoder.dispatchWorkgroups(e.dispatch[0], e.dispatch[1], e.dispatch[2]), this.dispatchCountInPass++, (f || g().get("WEBGPU_DEFERRED_SUBMIT_BATCH_SIZE") <= this.dispatchCountInPass || e.pixelsOpType === re.DRAW) && (this.endComputePassEncoder(), f ? this.activeTimers.push({ name: e.constructor.name, query: this.getQueryTime() }) : this.submitQueue());
   }
   async getQueryTime() {
     if (!this.supportTimestampQuery)

package/dist/broadcast_to-DDaNMbX7.js

@@ -0,0 +1,28 @@
+import { q as h, u as f, w as p, x as g, E as u, T } from "./index-D0RBWjq8.js";
+import { r as b } from "./reshape-CkjKPPqB.js";
+function m(e, r) {
+  let n = f(e, "broadcastTo", "x");
+  const a = n.shape;
+  if (p(r), r.length < n.rank)
+    throw new Error(`broadcastTo(): shape.length=${r.length} < input.rank=${n.rank}.`);
+  if (r.length > n.rank) {
+    const t = n.shape.slice();
+    for (; t.length < r.length; )
+      t.unshift(1);
+    n = b(n, t);
+  }
+  const s = n.shape, o = Array.from(r);
+  for (let t = r.length - 1; t >= 0; t--)
+    if (s[t] === r[t])
+      o[t] = 1;
+    else if (n.shape[t] !== 1)
+      throw new Error(`broadcastTo(): [${a}] cannot be broadcast to [${r}].`);
+  if (o.map((t, l) => t > 1 ? l : -1).filter((t) => t >= 0).length === 0)
+    return g(n);
+  const i = { x: n }, c = { reps: o };
+  return u.runKernel(T, i, c);
+}
+const E = /* @__PURE__ */ h({ broadcastTo_: m });
+export {
+  E as b
+};

package/dist/checks/appendCache.js

@@ -1,5 +1,5 @@
-import { s, e as a } from "../index-D6Q1lPZO.js";
-import { t } from "../tensor4d-D7bLqGqz.js";
+import { s, e as a } from "../index-D0RBWjq8.js";
+import { t } from "../tensor4d-DVwr7pLF.js";
 async function u(e) {
   await s(e);
   const n = t(

package/dist/checks/attentionMask.js

@@ -1,6 +1,6 @@
-import { s as i, e } from "../index-D6Q1lPZO.js";
-import { t } from "../tensor4d-D7bLqGqz.js";
-import { t as a } from "../tensor2d-CSB4KOb0.js";
+import { s as i, e } from "../index-D0RBWjq8.js";
+import { t } from "../tensor4d-DVwr7pLF.js";
+import { t as a } from "../tensor2d-BN1sSfQO.js";
 async function k(n) {
   await i(n);
   const s = t(

package/dist/checks/gelu.js

@@ -1,5 +1,5 @@
-import { s as e, e as o } from "../index-D6Q1lPZO.js";
-import { t as s } from "../tensor2d-CSB4KOb0.js";
+import { s as e, e as o } from "../index-D0RBWjq8.js";
+import { t as s } from "../tensor2d-BN1sSfQO.js";
 async function m(t) {
   await e(t);
   const r = s(

package/dist/checks/matMulGelu.js

@@ -1,11 +1,7 @@
-import { s as n, e as s } from "../index-D6Q1lPZO.js";
-import "../random_width-BVV9HveY.js";
-import "../register_all_kernels-nvj2k7OC.js";
-import "../index-Cp39cXWe.js";
-import "../dataset-D2P7rHAw.js";
-import { t as e } from "../tensor2d-CSB4KOb0.js";
-async function f(t) {
-  await n(t);
+import { s as o, e as s } from "../index-D0RBWjq8.js";
+import { t as e } from "../tensor2d-BN1sSfQO.js";
+async function i(t) {
+  await o(t);
   const r = e(
     [
       [0.1, 0.2, 9, 10, 11],
@@ -15,7 +11,7 @@ async function f(t) {
       [0.3, 0.4, -9, -10, -11]
     ],
     [5, 5]
-  ), o = e(
+  ), n = e(
     [
       [0.5, 0.6, 7e4, -8e3, 0],
       [0.7, 0.8, -7e4, 8e4, 0],
@@ -25,8 +21,8 @@ async function f(t) {
     ],
     [5, 5]
   );
-  return await s().runKernel("MatMulGelu", { x: o, kernel: r }).array();
+  return await s().runKernel("MatMulGelu", { x: n, kernel: r }).array();
 }
 export {
-  f as execute
+  i as execute
 };

package/dist/checks/normRMS.js

@@ -1,14 +1,14 @@
-import { s as i, u as A, e as y } from "../index-D6Q1lPZO.js";
-import { a as h } from "../ops-BFDtP6th.js";
-import { t as p } from "../tensor1d-BlUT89BP.js";
-import { t as a } from "../tensor-0r5yOo2R.js";
+import { s as u, a1 as A, e as y } from "../index-D0RBWjq8.js";
+import { a as h } from "../ops-FJapAPfm.js";
+import { t as p } from "../tensor1d-LxP9asMm.js";
+import { t as r } from "../tensor-BQqrDvpx.js";
 const w = Array.from({ length: 2048 * 192 }, () => Math.random()), x = Array.from({ length: 192 }, () => Math.random()), M = Array.from({ length: 2048 * 192 }, () => Math.random());
 async function k(t) {
-  await i(t);
-  const o = p(x, "float32"), n = a(w, [16, 128, 192], "float32"), s = a(M, [16, 128, 192], "float32"), e = (d, g) => {
-    const u = y().runKernel("RMSNorm", { x: d, gamma: g });
-    return h.meanSquaredError(u, s);
-  }, { value: m, grads: r } = A(e)([n, o]), c = await m.array(), f = await r[0].array(), l = await r[1].array();
+  await u(t);
+  const o = p(x, "float32"), n = r(w, [16, 128, 192], "float32"), s = r(M, [16, 128, 192], "float32"), e = (d, g) => {
+    const i = y().runKernel("RMSNorm", { x: d, gamma: g });
+    return h.meanSquaredError(i, s);
+  }, { value: m, grads: a } = A(e)([n, o]), c = await m.array(), f = await a[0].array(), l = await a[1].array();
   return [c, f, l];
 }
 export {

package/dist/checks/normRMSGrad.js

@@ -1,6 +1,6 @@
-import { s as c, e as d } from "../index-D6Q1lPZO.js";
-import { t as f } from "../tensor1d-BlUT89BP.js";
-import { t as r } from "../tensor-0r5yOo2R.js";
+import { s as c, e as d } from "../index-D0RBWjq8.js";
+import { t as f } from "../tensor1d-LxP9asMm.js";
+import { t as r } from "../tensor-BQqrDvpx.js";
 const y = Array.from({ length: 2048 * 192 }, () => Math.random()), i = Array.from({ length: 192 }, () => Math.random()), l = Array.from({ length: 2048 * 192 }, () => Math.random());
 async function x(t) {
   await c(t);