Release Compass Tiny v2.1: tested v24 q4f16 WebGPU, validation and caveats

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+onnx/model_q4f16.onnx_data filter=lfs diff=lfs merge=lfs -text
+onnx/model_q4f16.onnx_data_1 filter=lfs diff=lfs merge=lfs -text
+tokenizer.json filter=lfs diff=lfs merge=lfs -text

ARTIFACTS.json

@@ -0,0 +1,261 @@
+{
+  "format": "exact-v24-webgpu-q4f16-plus-explicit-integration-helper",
+  "manifestExcludesItself": true,
+  "files": [
+    {
+      "path": "ATTRIBUTIONS.md",
+      "bytes": 964,
+      "sha256": "3d83117ca74892774eedf2c3288ba864de05e4f0fe242bb4d09885e8634100a6"
+    },
+    {
+      "path": "chat_template.jinja",
+      "bytes": 8986,
+      "sha256": "23ac861c8370f36819f4f6034c4439ff631e3c381855749451a02be85d19b2d6"
+    },
+    {
+      "path": "config.json",
+      "bytes": 951,
+      "sha256": "504e5e43d11c25189f59896801302a8c40b3caf14cedc9dd9dc050c6430dcc01"
+    },
+    {
+      "path": "generation_config.json",
+      "bytes": 186,
+      "sha256": "6f66aa5aaf68145027c3f3c384abfd837530fe4d1efb582e0aa919eecd4c9a8e"
+    },
+    {
+      "path": "integration/minicpm5-tool-parser.mjs",
+      "bytes": 5307,
+      "sha256": "0f1bf7265771ec5cf73147c299c52490086579bb2d2c9885cbddda7e067322e3"
+    },
+    {
+      "path": "integration/parser.test.mjs",
+      "bytes": 2376,
+      "sha256": "ca3a366878b648e4daeba1674aead2c9b2a11f21c6308ed3a416c986632521ba"
+    },
+    {
+      "path": "onnx/model_q4f16.onnx",
+      "bytes": 362892,
+      "sha256": "ab10bc051ca80ad6dffe5045acac030d0d6b75c52d90db363d044f1f214fccfa"
+    },
+    {
+      "path": "onnx/model_q4f16.onnx_data",
+      "bytes": 1596739584,
+      "sha256": "2abad6aebb250a04619df22e8b2cab9998ee92ba083ec5426c97ae1beb8476f7"
+    },
+    {
+      "path": "onnx/model_q4f16.onnx_data_1",
+      "bytes": 272252928,
+      "sha256": "715887fa2ce24f2f1d5f5f8adaebc0caac4bad02e7d4d90e081f85decefec244"
+    },
+    {
+      "path": "PROVENANCE.json",
+      "bytes": 11378,
+      "sha256": "f6cd6d8e5f4947c2b09308731dd58352c7c4a4897dedfeed1e81baf2837e97d9"
+    },
+    {
+      "path": "README.md",
+      "bytes": 8044,
+      "sha256": "e601af5ecf40c128ba3510f1c1a89edc1d63013901490b30e569311ffae3235c"
+    },
+    {
+      "path": "runtime/inference-worker.js",
+      "bytes": 58199,
+      "sha256": "6e8863a72f022fa8d12207d4029f8f33f339f3c2c066497618065cf642da85dd"
+    },
+    {
+      "path": "runtime/tool-call-parser.js",
+      "bytes": 18197,
+      "sha256": "7a33bbcd31cc3910a169e735541c4d5189f85480237577f262de3154ce91f12d"
+    },
+    {
+      "path": "runtime/vendor/LICENSE.onnxruntime.txt",
+      "bytes": 1073,
+      "sha256": "2f07c72751aed99790b8a4869cf2311df85a860b22ded05fa22803587a48922c"
+    },
+    {
+      "path": "runtime/vendor/LICENSE.transformers.txt",
+      "bytes": 11358,
+      "sha256": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30"
+    },
+    {
+      "path": "runtime/vendor/onnxruntime-common/backend-impl.js",
+      "bytes": 5339,
+      "sha256": "97dd81b055a06f61120f09468fe59f046a9262b7b87bf5d05bceb085bf4f5558"
+    },
+    {
+      "path": "runtime/vendor/onnxruntime-common/backend.js",
+      "bytes": 184,
+      "sha256": "017ce2ec9dc2021ebc1ef2c4f04e1bc74276c65921b0297e7ed8cc16e640495b"
+    },
+    {
+      "path": "runtime/vendor/onnxruntime-common/env-impl.js",
+      "bytes": 848,
+      "sha256": "0da4c562a49fe147e19320a64cbb456184eb0e6242b1fe69c65c8368c55f3d97"
+    },
+    {
+      "path": "runtime/vendor/onnxruntime-common/env.js",
+      "bytes": 262,
+      "sha256": "b2bbd3d3b00a95765713c57cd0f5ef73718ae5b8322e07cb47a43e2accb21f15"
+    },
+    {
+      "path": "runtime/vendor/onnxruntime-common/index.js",
+      "bytes": 1036,
+      "sha256": "ad23f6d6ce2c99c449031f24a5181f259516c64a9a67428c98a8539b857729bd"
+    },
+    {
+      "path": "runtime/vendor/onnxruntime-common/inference-session-impl.js",
+      "bytes": 8703,
+      "sha256": "0446814a392c147b5c38ba242d9911ee54002b5d01a8e19fb4895fb8f8a0cdd3"
+    },
+    {
+      "path": "runtime/vendor/onnxruntime-common/inference-session.js",
+      "bytes": 348,
+      "sha256": "3ad4271a88edb3d242dc1e0e7bbf66510f9a56eff874c433b3b37f900ac007b1"
+    },
+    {
+      "path": "runtime/vendor/onnxruntime-common/onnx-model.js",
+      "bytes": 145,
+      "sha256": "9e9dc8678be0ea04575a542894508db355a4f9f2155ac7f4c17a697c5f843382"
+    },
+    {
+      "path": "runtime/vendor/onnxruntime-common/onnx-value.js",
+      "bytes": 145,
+      "sha256": "33dc232498753fc9026dfa44c99440cb1a6d29f3e53e1ad2fb8b696705158f06"
+    },
+    {
+      "path": "runtime/vendor/onnxruntime-common/tensor-conversion-impl.js",
+      "bytes": 7852,
+      "sha256": "df6fa3cd1813c2d3e588cc07973cfe5ea2ab8647c957168200caa58e51440161"
+    },
+    {
+      "path": "runtime/vendor/onnxruntime-common/tensor-conversion.js",
+      "bytes": 152,
+      "sha256": "8c43ec1d061ab71032a1b28f45d85ef95f8d7bd2d4cd71d059e96d83e3a8f422"
+    },
+    {
+      "path": "runtime/vendor/onnxruntime-common/tensor-factory-impl.js",
+      "bytes": 11002,
+      "sha256": "cf5606fe23461e01bff59c2d72ac47d74e652548718f1e5fab07a22b441379b4"
+    },
+    {
+      "path": "runtime/vendor/onnxruntime-common/tensor-factory.js",
+      "bytes": 149,
+      "sha256": "68b9f4f4573f25012ce8a4f73c9a2cee3a28db91de8bbb0a20ddb08bcba33c4b"
+    },
+    {
+      "path": "runtime/vendor/onnxruntime-common/tensor-impl-type-mapping.js",
+      "bytes": 2706,
+      "sha256": "20bd5ddb858954cf071bace6c7a6628c8e311433798ec172f4c778bebd81d407"
+    },
+    {
+      "path": "runtime/vendor/onnxruntime-common/tensor-impl.js",
+      "bytes": 16091,
+      "sha256": "6a749be63055f9d21069566b1515412484a3a03448ca20427c8f8d29328a2843"
+    },
+    {
+      "path": "runtime/vendor/onnxruntime-common/tensor-utils-impl.js",
+      "bytes": 1920,
+      "sha256": "87d3e07c153616138c2f57846545eea9c47957c714d50c0264696bdc293e6732"
+    },
+    {
+      "path": "runtime/vendor/onnxruntime-common/tensor-utils.js",
+      "bytes": 147,
+      "sha256": "7acfdb2f8403ae84b7ae62d55d6eeb01519108be8874337b317b911ed60190cd"
+    },
+    {
+      "path": "runtime/vendor/onnxruntime-common/tensor.js",
+      "bytes": 286,
+      "sha256": "721d24a538de5333057bfc423bc00c3453a1c483f4495c857d0a6f9b8f2d330e"
+    },
+    {
+      "path": "runtime/vendor/onnxruntime-common/trace.js",
+      "bytes": 1891,
+      "sha256": "9b87e6309a1c502b03558aa94b0a65c8ea1e8eb59cb46090f54f6eacd191b841"
+    },
+    {
+      "path": "runtime/vendor/onnxruntime-common/type-helper.js",
+      "bytes": 146,
+      "sha256": "3e2588c6a5ee7b9755e199eef10c6aa2e777d0366ea47d27953657a5638deeae"
+    },
+    {
+      "path": "runtime/vendor/onnxruntime-common/version.js",
+      "bytes": 263,
+      "sha256": "00a18ffb867b29a3855fe00e965797dba270849134f1e0ab2929fb2761c0fe44"
+    },
+    {
+      "path": "runtime/vendor/ort-wasm-simd-threaded.asyncify.mjs",
+      "bytes": 47507,
+      "sha256": "7236653b8565da4046e459cd0e274123419a1d9f1f8f18fd36c28058346ca655"
+    },
+    {
+      "path": "runtime/vendor/ort-wasm-simd-threaded.asyncify.wasm",
+      "bytes": 24254953,
+      "sha256": "7e83cd6cee77e478bc96a7e91b198144fb5e4126287daf1f9b54bb195ebcd55a"
+    },
+    {
+      "path": "runtime/vendor/ort.webgpu.mjs",
+      "bytes": 679694,
+      "sha256": "177cf67f3e6c25e951a76a981a857e6af53b1571016685cc2480e1e6e47b1d46"
+    },
+    {
+      "path": "runtime/vendor/README.md",
+      "bytes": 8373,
+      "sha256": "a3b6d952b825a7382f16f89c1431e57090e6c3c2d1267ce1548069c802c103c7"
+    },
+    {
+      "path": "runtime/vendor/ThirdPartyNotices.onnxruntime.txt",
+      "bytes": 325054,
+      "sha256": "0e07b95f3a8d6230037707c5c4a2b554d12c4cb67369669ac255635528ffcee2"
+    },
+    {
+      "path": "runtime/vendor/transformers.web.js",
+      "bytes": 1099925,
+      "sha256": "83e3edd00c98fef962da9bdc22fe4b63b3858743a76c1b7e46bee8e483033644"
+    },
+    {
+      "path": "tokenizer.json",
+      "bytes": 10548223,
+      "sha256": "c7dc553ba83607a7d3cde4782e4055fcd15cb228f8f1cdc3fc149b1094580592"
+    },
+    {
+      "path": "tokenizer_config.json",
+      "bytes": 9706,
+      "sha256": "f8a13de1b9989de61731cf9ce5805a9c3da2aad822ded0cd5375cc3d1206e24c"
+    },
+    {
+      "path": "validation/cold-cache-results.json",
+      "bytes": 988,
+      "sha256": "ea1382b4cf397eed54510c2ac362f8c53c519d1a0bacd58a5266a44ceffb8972"
+    },
+    {
+      "path": "validation/context-results.json",
+      "bytes": 693,
+      "sha256": "c59e23f5038d5a6dd3d4e67f7ba90036d24af117a5c834221e30fc533a44e565"
+    },
+    {
+      "path": "validation/numerical-results.json",
+      "bytes": 8506,
+      "sha256": "d8d09941d44038efe040ad748d034d217f7e43227cd28ff5e47edfe061c80d4f"
+    },
+    {
+      "path": "validation/parser-results.json",
+      "bytes": 2257,
+      "sha256": "b50a394c4ddd5cfacf9208e8b8cbd39e3a048dbab5211bebc781ffb612f06bb1"
+    },
+    {
+      "path": "validation/parser-unit-tests.json",
+      "bytes": 804,
+      "sha256": "cdeef39b880727cf70b0578dd90dec8941edd007fa3eae0225cbbf6810bd4626"
+    },
+    {
+      "path": "validation/routing-results.json",
+      "bytes": 1316,
+      "sha256": "924be9a083ccd11206a528f6e63c64f743078e9a451a69fe968ba6f98cfcc2a4"
+    },
+    {
+      "path": "validation/smoke-results.json",
+      "bytes": 2009,
+      "sha256": "9f478ce6bd8c9f6ddb145e4468ae31f5290a8aaedfa4673a06483f1b0e7b66c9"
+    }
+  ]
+}

ATTRIBUTIONS.md

@@ -0,0 +1,17 @@
+# Source attributions and project restrictions
+
+Base: OpenBMB MiniCPM5-2B, revision 3497c460c89e00520c3cfa2e73f49ab7647f1177,
+Apache-2.0. https://huggingface.co/openbmb/MiniCPM5-2B
+Modified by WebBrain through LoRA training and full-model merging.
+Original authors do not endorse this derived release.
+
+Training dataset: https://huggingface.co/datasets/webbrain-one/webbrain-compass-v2-dataset
+Preserve the source attributions, manifests and restrictions in that private repository.
+WebLINX: McGill-NLP contributors, CC BY-NC-SA 4.0.
+https://huggingface.co/datasets/McGill-NLP/weblinx
+https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode.en
+
+Project policy restricts this derived model to noncommercial research. Preserve
+all source terms, attribution and applicable share-alike obligations. Private
+hosting does not grant commercial rights. This is an experimental release with
+a disclosed failed behavioral gate, not a claim of general safety or success.

PROVENANCE.json

@@ -0,0 +1,270 @@
+{
+  "releaseName": "WebBrain Compass Tiny v2.1",
+  "repository": "webbrain-one/webbrain-compass-tiny-v2.1",
+  "candidate": "v24",
+  "status": "private-experimental-release-authorized",
+  "authorization": "Owner requested release of v24 as webbrain-compass-tiny-v2.1 after receiving the numerical pass, parser caveat and three discouraged-action results. Private visibility retained.",
+  "numericalValidationPassed": true,
+  "numericalToleranceChanged": false,
+  "behavioralGatePassed": false,
+  "productionReleaseApproved": false,
+  "endToEndBrowserTaskSuccessMeasured": false,
+  "sourcePackageProofSha256": "dc91e19a96db79d51d77c15c1e03f755249021ae0fbf3403e4606ed877a664a1",
+  "sourceNumericalCompletionSha256": "d8d09941d44038efe040ad748d034d217f7e43227cd28ff5e47edfe061c80d4f",
+  "sourceBehavioralAuditSha256": "43e5a2d408995796994245d396a1b61522fe1185574b29fb07e47ff8de7a7365",
+  "historicalEvidenceUnchanged": true,
+  "change": "Same trained model; 211 MatMulNBits accuracy_level attributes 4 -> 2; no weight, tokenizer or runtime changes.",
+  "sourceBf16Repo": "webbrain-one/webbrain-compass-tiny-v2",
+  "sourceBf16Revision": "54bcab6731939137d0489ac01463c9404dff9da8",
+  "priorRelease": {
+    "repo": "webbrain-one/webbrain-compass-tiny-v2-onnx",
+    "revision": "efddf2666bced055e9b04e745197b4e7d56734e0",
+    "unchanged": true
+  },
+  "testedTransportAlias": "webbrain-one/webbrain-compass-tiny-v2-onnx",
+  "newRepoIsTransportRenameOnly": true,
+  "browser": "150.0.7871.187",
+  "hardware": "NVIDIA RTX 5090",
+  "runtime": {
+    "transformers.js": "4.2.0",
+    "onnxruntime-web": "1.27.0"
+  },
+  "testedBytes": [
+    {
+      "sourcePath": "bundle/chat_template.jinja",
+      "path": "chat_template.jinja",
+      "bytes": 8986,
+      "sha256": "23ac861c8370f36819f4f6034c4439ff631e3c381855749451a02be85d19b2d6"
+    },
+    {
+      "sourcePath": "bundle/config.json",
+      "path": "config.json",
+      "bytes": 951,
+      "sha256": "504e5e43d11c25189f59896801302a8c40b3caf14cedc9dd9dc050c6430dcc01"
+    },
+    {
+      "sourcePath": "bundle/generation_config.json",
+      "path": "generation_config.json",
+      "bytes": 186,
+      "sha256": "6f66aa5aaf68145027c3f3c384abfd837530fe4d1efb582e0aa919eecd4c9a8e"
+    },
+    {
+      "sourcePath": "bundle/onnx/model_q4f16.onnx",
+      "path": "onnx/model_q4f16.onnx",
+      "bytes": 362892,
+      "sha256": "ab10bc051ca80ad6dffe5045acac030d0d6b75c52d90db363d044f1f214fccfa"
+    },
+    {
+      "sourcePath": "bundle/onnx/model_q4f16.onnx_data",
+      "path": "onnx/model_q4f16.onnx_data",
+      "bytes": 1596739584,
+      "sha256": "2abad6aebb250a04619df22e8b2cab9998ee92ba083ec5426c97ae1beb8476f7"
+    },
+    {
+      "sourcePath": "bundle/onnx/model_q4f16.onnx_data_1",
+      "path": "onnx/model_q4f16.onnx_data_1",
+      "bytes": 272252928,
+      "sha256": "715887fa2ce24f2f1d5f5f8adaebc0caac4bad02e7d4d90e081f85decefec244"
+    },
+    {
+      "sourcePath": "bundle/tokenizer.json",
+      "path": "tokenizer.json",
+      "bytes": 10548223,
+      "sha256": "c7dc553ba83607a7d3cde4782e4055fcd15cb228f8f1cdc3fc149b1094580592"
+    },
+    {
+      "sourcePath": "bundle/tokenizer_config.json",
+      "path": "tokenizer_config.json",
+      "bytes": 9706,
+      "sha256": "f8a13de1b9989de61731cf9ce5805a9c3da2aad822ded0cd5375cc3d1206e24c"
+    },
+    {
+      "sourcePath": "runtime/inference-worker.js",
+      "path": "runtime/inference-worker.js",
+      "bytes": 58199,
+      "sha256": "6e8863a72f022fa8d12207d4029f8f33f339f3c2c066497618065cf642da85dd"
+    },
+    {
+      "sourcePath": "runtime/tool-call-parser.js",
+      "path": "runtime/tool-call-parser.js",
+      "bytes": 18197,
+      "sha256": "7a33bbcd31cc3910a169e735541c4d5189f85480237577f262de3154ce91f12d"
+    },
+    {
+      "sourcePath": "runtime/vendor/LICENSE.onnxruntime.txt",
+      "path": "runtime/vendor/LICENSE.onnxruntime.txt",
+      "bytes": 1073,
+      "sha256": "2f07c72751aed99790b8a4869cf2311df85a860b22ded05fa22803587a48922c"
+    },
+    {
+      "sourcePath": "runtime/vendor/LICENSE.transformers.txt",
+      "path": "runtime/vendor/LICENSE.transformers.txt",
+      "bytes": 11358,
+      "sha256": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30"
+    },
+    {
+      "sourcePath": "runtime/vendor/onnxruntime-common/backend-impl.js",
+      "path": "runtime/vendor/onnxruntime-common/backend-impl.js",
+      "bytes": 5339,
+      "sha256": "97dd81b055a06f61120f09468fe59f046a9262b7b87bf5d05bceb085bf4f5558"
+    },
+    {
+      "sourcePath": "runtime/vendor/onnxruntime-common/backend.js",
+      "path": "runtime/vendor/onnxruntime-common/backend.js",
+      "bytes": 184,
+      "sha256": "017ce2ec9dc2021ebc1ef2c4f04e1bc74276c65921b0297e7ed8cc16e640495b"
+    },
+    {
+      "sourcePath": "runtime/vendor/onnxruntime-common/env-impl.js",
+      "path": "runtime/vendor/onnxruntime-common/env-impl.js",
+      "bytes": 848,
+      "sha256": "0da4c562a49fe147e19320a64cbb456184eb0e6242b1fe69c65c8368c55f3d97"
+    },
+    {
+      "sourcePath": "runtime/vendor/onnxruntime-common/env.js",
+      "path": "runtime/vendor/onnxruntime-common/env.js",
+      "bytes": 262,
+      "sha256": "b2bbd3d3b00a95765713c57cd0f5ef73718ae5b8322e07cb47a43e2accb21f15"
+    },
+    {
+      "sourcePath": "runtime/vendor/onnxruntime-common/index.js",
+      "path": "runtime/vendor/onnxruntime-common/index.js",
+      "bytes": 1036,
+      "sha256": "ad23f6d6ce2c99c449031f24a5181f259516c64a9a67428c98a8539b857729bd"
+    },
+    {
+      "sourcePath": "runtime/vendor/onnxruntime-common/inference-session-impl.js",
+      "path": "runtime/vendor/onnxruntime-common/inference-session-impl.js",
+      "bytes": 8703,
+      "sha256": "0446814a392c147b5c38ba242d9911ee54002b5d01a8e19fb4895fb8f8a0cdd3"
+    },
+    {
+      "sourcePath": "runtime/vendor/onnxruntime-common/inference-session.js",
+      "path": "runtime/vendor/onnxruntime-common/inference-session.js",
+      "bytes": 348,
+      "sha256": "3ad4271a88edb3d242dc1e0e7bbf66510f9a56eff874c433b3b37f900ac007b1"
+    },
+    {
+      "sourcePath": "runtime/vendor/onnxruntime-common/onnx-model.js",
+      "path": "runtime/vendor/onnxruntime-common/onnx-model.js",
+      "bytes": 145,
+      "sha256": "9e9dc8678be0ea04575a542894508db355a4f9f2155ac7f4c17a697c5f843382"
+    },
+    {
+      "sourcePath": "runtime/vendor/onnxruntime-common/onnx-value.js",
+      "path": "runtime/vendor/onnxruntime-common/onnx-value.js",
+      "bytes": 145,
+      "sha256": "33dc232498753fc9026dfa44c99440cb1a6d29f3e53e1ad2fb8b696705158f06"
+    },
+    {
+      "sourcePath": "runtime/vendor/onnxruntime-common/tensor-conversion-impl.js",
+      "path": "runtime/vendor/onnxruntime-common/tensor-conversion-impl.js",
+      "bytes": 7852,
+      "sha256": "df6fa3cd1813c2d3e588cc07973cfe5ea2ab8647c957168200caa58e51440161"
+    },
+    {
+      "sourcePath": "runtime/vendor/onnxruntime-common/tensor-conversion.js",
+      "path": "runtime/vendor/onnxruntime-common/tensor-conversion.js",
+      "bytes": 152,
+      "sha256": "8c43ec1d061ab71032a1b28f45d85ef95f8d7bd2d4cd71d059e96d83e3a8f422"
+    },
+    {
+      "sourcePath": "runtime/vendor/onnxruntime-common/tensor-factory-impl.js",
+      "path": "runtime/vendor/onnxruntime-common/tensor-factory-impl.js",
+      "bytes": 11002,
+      "sha256": "cf5606fe23461e01bff59c2d72ac47d74e652548718f1e5fab07a22b441379b4"
+    },
+    {
+      "sourcePath": "runtime/vendor/onnxruntime-common/tensor-factory.js",
+      "path": "runtime/vendor/onnxruntime-common/tensor-factory.js",
+      "bytes": 149,
+      "sha256": "68b9f4f4573f25012ce8a4f73c9a2cee3a28db91de8bbb0a20ddb08bcba33c4b"
+    },
+    {
+      "sourcePath": "runtime/vendor/onnxruntime-common/tensor-impl-type-mapping.js",
+      "path": "runtime/vendor/onnxruntime-common/tensor-impl-type-mapping.js",
+      "bytes": 2706,
+      "sha256": "20bd5ddb858954cf071bace6c7a6628c8e311433798ec172f4c778bebd81d407"
+    },
+    {
+      "sourcePath": "runtime/vendor/onnxruntime-common/tensor-impl.js",
+      "path": "runtime/vendor/onnxruntime-common/tensor-impl.js",
+      "bytes": 16091,
+      "sha256": "6a749be63055f9d21069566b1515412484a3a03448ca20427c8f8d29328a2843"
+    },
+    {
+      "sourcePath": "runtime/vendor/onnxruntime-common/tensor-utils-impl.js",
+      "path": "runtime/vendor/onnxruntime-common/tensor-utils-impl.js",
+      "bytes": 1920,
+      "sha256": "87d3e07c153616138c2f57846545eea9c47957c714d50c0264696bdc293e6732"
+    },
+    {
+      "sourcePath": "runtime/vendor/onnxruntime-common/tensor-utils.js",
+      "path": "runtime/vendor/onnxruntime-common/tensor-utils.js",
+      "bytes": 147,
+      "sha256": "7acfdb2f8403ae84b7ae62d55d6eeb01519108be8874337b317b911ed60190cd"
+    },
+    {
+      "sourcePath": "runtime/vendor/onnxruntime-common/tensor.js",
+      "path": "runtime/vendor/onnxruntime-common/tensor.js",
+      "bytes": 286,
+      "sha256": "721d24a538de5333057bfc423bc00c3453a1c483f4495c857d0a6f9b8f2d330e"
+    },
+    {
+      "sourcePath": "runtime/vendor/onnxruntime-common/trace.js",
+      "path": "runtime/vendor/onnxruntime-common/trace.js",
+      "bytes": 1891,
+      "sha256": "9b87e6309a1c502b03558aa94b0a65c8ea1e8eb59cb46090f54f6eacd191b841"
+    },
+    {
+      "sourcePath": "runtime/vendor/onnxruntime-common/type-helper.js",
+      "path": "runtime/vendor/onnxruntime-common/type-helper.js",
+      "bytes": 146,
+      "sha256": "3e2588c6a5ee7b9755e199eef10c6aa2e777d0366ea47d27953657a5638deeae"
+    },
+    {
+      "sourcePath": "runtime/vendor/onnxruntime-common/version.js",
+      "path": "runtime/vendor/onnxruntime-common/version.js",
+      "bytes": 263,
+      "sha256": "00a18ffb867b29a3855fe00e965797dba270849134f1e0ab2929fb2761c0fe44"
+    },
+    {
+      "sourcePath": "runtime/vendor/ort-wasm-simd-threaded.asyncify.mjs",
+      "path": "runtime/vendor/ort-wasm-simd-threaded.asyncify.mjs",
+      "bytes": 47507,
+      "sha256": "7236653b8565da4046e459cd0e274123419a1d9f1f8f18fd36c28058346ca655"
+    },
+    {
+      "sourcePath": "runtime/vendor/ort-wasm-simd-threaded.asyncify.wasm",
+      "path": "runtime/vendor/ort-wasm-simd-threaded.asyncify.wasm",
+      "bytes": 24254953,
+      "sha256": "7e83cd6cee77e478bc96a7e91b198144fb5e4126287daf1f9b54bb195ebcd55a"
+    },
+    {
+      "sourcePath": "runtime/vendor/ort.webgpu.mjs",
+      "path": "runtime/vendor/ort.webgpu.mjs",
+      "bytes": 679694,
+      "sha256": "177cf67f3e6c25e951a76a981a857e6af53b1571016685cc2480e1e6e47b1d46"
+    },
+    {
+      "sourcePath": "runtime/vendor/README.md",
+      "path": "runtime/vendor/README.md",
+      "bytes": 8373,
+      "sha256": "a3b6d952b825a7382f16f89c1431e57090e6c3c2d1267ce1548069c802c103c7"
+    },
+    {
+      "sourcePath": "runtime/vendor/ThirdPartyNotices.onnxruntime.txt",
+      "path": "runtime/vendor/ThirdPartyNotices.onnxruntime.txt",
+      "bytes": 325054,
+      "sha256": "0e07b95f3a8d6230037707c5c4a2b554d12c4cb67369669ac255635528ffcee2"
+    },
+    {
+      "sourcePath": "runtime/vendor/transformers.web.js",
+      "path": "runtime/vendor/transformers.web.js",
+      "bytes": 1099925,
+      "sha256": "83e3edd00c98fef962da9bdc22fe4b63b3858743a76c1b7e46bee8e483033644"
+    }
+  ],
+  "optionalParserIncludedSeparately": true,
+  "bundledParserReplaced": false
+}

README.md

@@ -0,0 +1,153 @@
+---
+license: other
+license_name: webbrain-noncommercial-research-restrictions
+license_link: https://huggingface.co/webbrain-one/webbrain-compass-tiny-v2.1/blob/main/ATTRIBUTIONS.md
+library_name: transformers.js
+base_model: webbrain-one/webbrain-compass-tiny-v2
+pipeline_tag: text-generation
+tags:
+- onnx
+- webgpu
+- q4f16
+- gptq
+- tool-calling
+- experimental
+---
+# WebBrain Compass Tiny v2.1
+
+**Private experimental q4f16/WebGPU release of the tested v24 candidate.**
+Based on WebBrain Compass Tiny v2, a fine-tune of **OpenBMB MiniCPM5-2B (~2.6B parameters)**.
+v2.1 is an **export/runtime revision**, not a new training run. The merged BF16 source remains
+`webbrain-one/webbrain-compass-tiny-v2` at `54bcab6731939137d0489ac01463c9404dff9da8`.
+The previous v23 release is separate and unchanged.
+
+## What improved
+
+Only the ONNX graph's 211 `MatMulNBits` `accuracy_level` attributes changed from 4 to 2,
+disabling the dynamic INT8-activation path used in the pinned WebGPU runtime. Quantized
+weight shards, tokenizer, config and vendored runtime remain byte-identical to v23.
+
+| Check | v23 | v2.1 / v24 |
+|---|---:|---:|
+| Quantized PyTorch vs WebGPU numerical checks | 2/12 pass | **12/12 pass** |
+| Worst relative RMS logit difference; unchanged limit 2% | 6.5274% | **1.8334%** |
+| Minimum cosine; unchanged limit 0.999 | 0.998065500 | **0.999833960** |
+
+Generation smoke (8 cases), bounded **16,384-total-token** context/cache checks, and a
+cold-browser restart with model downloads disabled passed. All three cold-cache native
+tool-call outputs were unchanged. Numerical tests cover three prompts, prefill plus
+three cached steps each, with identical token prefixes. They establish runtime parity
+in those probes—not BF16 equivalence, universal numerical accuracy, or a percentage
+loss in task accuracy. INT4 quality loss remains a separate issue; a Turkish smoke
+response remained awkward despite passing structural checks.
+
+## Fixed next-response routing results
+
+| Metric | BF16 reference | v2.1 / v24 WebGPU |
+|---|---:|---:|
+| First-turn structured calls | 94/100 | **98/100** |
+| Strict exact action | 16/89 | **15/89** |
+| Loose tool-family match | 41/89 | **43/89** |
+
+This is **not end-to-end browser-agent task success or an Online-Mind2Web result**.
+One run: 100 first-turn cases, 89 scored scenarios and 11 predetermined skips;
+194 raw responses including 5 smoke requests were retained locally. The 193 pinned
+input files match the BF16 reference, but precision, runtime and JS/Torch random
+generators differ. No output repair, model helper, fallback or result-based retry.
+
+**The full predeclared behavioral gate failed:** 3 explicitly discouraged actions
+versus a limit of 1. These were retrying an access-blocked URL, continuing a listing
+before reporting available results, and inventing a pagination URL. Other declared
+gates passed, with zero transport errors, zero native-decoder parser errors and zero
+length-limited responses. The owner authorized this separate release with these
+findings disclosed; it is not certified for unattended consequential actions.
+
+## Exact package
+
+- GPTQ asymmetric INT4 weights, group size 32; FP16 scales/activations/KV cache.
+- Default graph: `onnx/model_q4f16.onnx`. **Both** external data files are required:
+  `model_q4f16.onnx_data` and `model_q4f16.onnx_data_1` (1,868,992,512 bytes combined).
+- The inherited BF16 dtype and 131072 architecture field in `config.json` do not
+  describe this quantized graph or establish a tested browser context limit.
+- Exact tested runtime under `runtime/`: Transformers.js **4.2.0**, ONNX Runtime Web
+  **1.27.0**, WebBrain worker/parser and dependency licences. Tested with Chrome
+  **150.0.7871.187**, NVIDIA **RTX 5090**. Other devices/runtimes are not verified here.
+- Generation-only, last-token logits; thinking disabled. No cloud or visual model.
+- Tests used a local model transport alias; this repository name is the release
+  identifier. All 39 tested model/runtime files are mapped and hashed in provenance.
+- `validation/` contains results and compact audit summaries. Complete original
+  local audit hashes are recorded; private training/calibration data, browser profiles,
+  credentials and raw benchmark requests are not included.
+
+## Integration
+
+1. Download the **pinned commit returned with the release**, using an HF account with
+   private-repository access:
+
+   ```sh
+   hf download webbrain-one/webbrain-compass-tiny-v2.1 --revision <PINNED_COMMIT> --local-dir ./compass-tiny-v2.1
+   ```
+
+   Keep `onnx/`, tokenizer/config files and both external shards together. Never embed
+   a personal/write token in an extension, webpage, source file or log. Use a trusted
+   authenticated asset proxy or a private local mirror pinned to that same commit.
+   Anonymous HF downloads cannot access this private release.
+
+2. In WebBrain, choose the custom model ID `webbrain-one/webbrain-compass-tiny-v2.1`,
+   **device `webgpu`, dtype `q4f16`**, default filename stem `model`. Use the supplied
+   runtime assets. The unchanged worker has no revision option: pin the asset proxy,
+   or explicitly pass `revision` at pipeline initialization in your integration.
+   The new model ID has a separate cache key; do not alias it onto v23's cached graph.
+
+   Equivalent library initialization, with executable runtime assets served locally:
+
+   ```js
+   import { env, pipeline } from './runtime/vendor/transformers.web.js';
+   import { parseMiniCpmToolCalls } from './integration/minicpm5-tool-parser.mjs';
+
+   env.backends.onnx.wasm.numThreads = 1;
+   env.backends.onnx.wasm.wasmPaths = {
+     mjs: new URL('./runtime/vendor/ort-wasm-simd-threaded.asyncify.mjs', import.meta.url).href,
+     wasm: new URL('./runtime/vendor/ort-wasm-simd-threaded.asyncify.wasm', import.meta.url).href,
+   };
+   // Configure your trusted authenticated asset proxy before accessing this private repo.
+   const generator = await pipeline('text-generation',
+     'webbrain-one/webbrain-compass-tiny-v2.1', {
+       revision: '<PINNED_COMMIT>', device: 'webgpu', dtype: 'q4f16',
+       session_options: { extra: {
+         'ep.webgpuexecutionprovider.storageBufferCacheMode': 'simple',
+       } },
+     });
+   try {
+     const result = await generator(messages, {
+       tools, do_sample: false, max_new_tokens: 256,
+       tokenizer_encode_kwargs: { enable_thinking: false },
+     });
+     const generated = result[0].generated_text;
+     const text = Array.isArray(generated) ? generated.at(-1).content : generated;
+     const calls = parseMiniCpmToolCalls(text, tools);
+     // Retain raw text. Validate argument schemas and user authorization before dispatch.
+     // An empty calls list is not automatically successful task completion.
+   } finally {
+     await generator.dispose();
+   }
+   ```
+
+   The native custom-model worker defaults to greedy generation and caps output at
+   256 tokens. The routing benchmark used its documented test hook (4096-token budget,
+   temperature 0.15/0.3, seed 3407); do not claim those scores for the default UI settings.
+   Budget input plus output within the tested 16K limit and start with short tasks.
+
+3. **Parser integration is explicit, not silently changed.** The exact bundled parser
+   under `runtime/` matches 162/194 recorded native-decoder responses. It can leave
+   Python-style `False` and `['green', 'amber']` as strings. The optional, separately
+   audited `integration/minicpm5-tool-parser.mjs` matches **194/194** recorded responses
+   and passed its allowlist checks; it is not automatically wired into the worker.
+   Pass the full tool schemas so string-valued JSON bodies remain strings. The helper
+   does not execute literals, validate every schema constraint, or grant action approval.
+   Preserve downstream validation, confirmations and raw-output/error logging.
+
+   CPU-only helper checks: `node --test integration/parser.test.mjs`.
+
+This release remains subject to `ATTRIBUTIONS.md`, including the project's
+noncommercial-research restrictions. Private hosting does not expand usage rights.

chat_template.jinja

@@ -0,0 +1,176 @@
+{{- bos_token }}{%- if tools %}
+    {%- set tool_definitions %}
+        {{- "# Tools\n\nYou are provided with function signatures within <tools></tools> XML tags:\n<tools>" }}
+        {%- for tool in tools %}
+            {{- "\n" }}
+            {{- tool | tojson(ensure_ascii=False) }}
+        {%- endfor %}
+        {{- '\n</tools>\n\nTool usage guidelines:\n- You may call zero or more functions. If no function calls are needed, just answer normally and do not include any <function ... </function>.\n- When calling a function, return an XML object within <function ... </function> using:\n<function name="function-name"><param name="param-name">param-value</param></function>\n- param-value may be multi-line. If it contains <, & or newline characters, wrap it in a CDATA block: <param name="param-name"><![CDATA[...multi-line value...]]></param>' }}
+    {%- endset %}
+    
+    {{- '<|im_start|>system\n' }}
+    {%- if messages[0].role == 'system' %}
+        {%- if '<tool_def_sep>' in messages[0].content %}
+            {{- messages[0].content.replace('<tool_def_sep>', tool_definitions) }}
+        {%- else %}
+            {{- messages[0].content + '\n\n' + tool_definitions }}
+        {%- endif %}
+    {%- else %}
+        {{- tool_definitions.lstrip() }}
+    {%- endif %}
+    {{- '<|im_end|>\n' }}
+{%- else %}
+    {%- if messages[0].role == 'system' %}
+        {{- '<|im_start|>system\n' + messages[0].content + '<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %}
+{%- for message in messages[::-1] %}
+    {%- set index = (messages|length - 1) - loop.index0 %}
+    {%- if ns.multi_step_tool and message.role == "user" and message.content is string and not(message.content.startswith('<tool_response>') and message.content.endswith('</tool_response>')) %}
+        {%- set ns.multi_step_tool = false %}
+        {%- set ns.last_query_index = index %}
+    {%- endif %}
+{%- endfor %}
+{%- for message in messages %}
+    {%- if message.content is string %}
+        {%- set content = message.content %}
+    {%- else %}
+        {%- set content = '' %}
+    {%- endif %}
+    {%- if (message.role == "user") or (message.role == "system" and not loop.first) %}
+        {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {%- set reasoning_content = '' %}
+        {%- if message.reasoning_content is string %}
+            {%- set reasoning_content = message.reasoning_content %}
+        {%- else %}
+            {%- if '</think>' in content %}
+                {%- set reasoning_content = content.split('</think>')[0].rstrip('\n').split('<think>')[-1].lstrip('\n') %}
+                {%- set content = content.split('</think>')[-1].lstrip('\n') %}
+            {%- endif %}
+        {%- endif %}
+        
+        {%- if message.tool_calls %}
+            {%- set content_parts = content.split('<tool_sep>') %}
+            {%- set processed_content = content_parts[0] %}
+            {%- set tool_calls_count = message.tool_calls|length %}
+            {%- set tool_sep_count = content_parts|length - 1 %}
+            
+            {%- for i in range(1, content_parts|length) %}
+                {%- set tool_index = i - 1 %}
+                {%- if tool_index < tool_calls_count %}
+                    {%- set tool_call = message.tool_calls[tool_index] %}
+                    {%- if tool_call.function %}
+                        {%- set tool_call = tool_call.function %}
+                    {%- endif %}
+                    {%- set single_tool_xml %}
+                        {{- '<function name="' ~ tool_call.name ~ '">' }}
+                        {%- if tool_call.arguments %}
+                            {%- set args_dict = tool_call.arguments %}
+                            {%- for param_name, param_value in args_dict.items() %}
+                                {{- '<param name="' ~ param_name ~ '">' }}
+                                {%- if param_value is string and ('<' in param_value or '&' in param_value or '\n' in param_value) %}
+                                    {{- '<![CDATA[' + param_value + ']]>' }}
+                                {%- else %}
+                                    {{- param_value }}
+                                {%- endif %}
+                                {{- '</param>' }}
+                            {%- endfor %}
+                        {%- endif %}
+                        {{- '</function>' }}
+                    {%- endset %}
+                    {%- set processed_content = processed_content + single_tool_xml + content_parts[i] %}
+                {%- else %}
+                    {%- set processed_content = processed_content + content_parts[i] %}
+                {%- endif %}
+            {%- endfor %}
+            
+            {%- if tool_calls_count > tool_sep_count %}
+                {%- for remaining_index in range(tool_sep_count, tool_calls_count) %}
+                    {%- set tool_call = message.tool_calls[remaining_index] %}
+                    {%- if tool_call.function %}
+                        {%- set tool_call = tool_call.function %}
+                    {%- endif %}
+                    {%- set remaining_tool_xml %}
+                        {{- '<function name="' ~ tool_call.name ~ '">' }}
+                        {%- if tool_call.arguments %}
+                            {%- set args_dict = tool_call.arguments %}
+                            {%- for param_name, param_value in args_dict.items() %}
+                                {{- '<param name="' ~ param_name ~ '">' }}
+                                {%- if param_value is string and ('<' in param_value or '&' in param_value or '\n' in param_value) %}
+                                    {{- '<![CDATA[' + param_value + ']]>' }}
+                                {%- else %}
+                                    {{- param_value }}
+                                {%- endif %}
+                                {{- '</param>' }}
+                            {%- endfor %}
+                        {%- endif %}
+                        {{- '</function>' }}
+                    {%- endset %}
+                    {%- set processed_content = processed_content + remaining_tool_xml %}
+                {%- endfor %}
+            {%- endif %}
+            
+            {%- set content = processed_content %}
+        {%- endif %}
+        
+        {%- if reasoning_content %}
+            {{- '<|im_start|>' + message.role + '\n<think>\n' + reasoning_content.strip('\n') + '\n</think>\n\n' + content.lstrip('\n') }}
+        {%- elif '<think>' not in content and '</think>' not in content %}
+            {{- '<|im_start|>' + message.role + '\n<think>\n\n</think>\n\n' + content.lstrip('\n') }}
+        {%- else %}
+            {{- '<|im_start|>' + message.role + '\n' + content }}
+        {%- endif %}
+        
+        {%- if message.tool_calls and not has_tool_sep %}
+            {%- for tool_call in message.tool_calls %}
+                {%- if (loop.first and content) or (not loop.first) %}
+                    {{- '\n' }}
+                {%- endif %}
+                {%- if tool_call.function %}
+                    {%- set tool_call = tool_call.function %}
+                {%- endif %}
+                {{- '<function name="' ~ tool_call.name ~ '">' }}
+                {%- if tool_call.arguments %}
+                    {%- set args_dict = tool_call.arguments %}
+                    {%- for param_name, param_value in args_dict.items() %}
+                        {{- '<param name="' ~ param_name ~ '">' }}
+                        {%- if param_value is string and ('<' in param_value or '&' in param_value or '\n' in param_value) %}
+                            {{- '<![CDATA[' + param_value + ']]>' }}
+                        {%- else %}
+                            {{- param_value }}
+                        {%- endif %}
+                        {{- '</param>' }}
+                    {%- endfor %}
+                {%- endif %}
+                {{- '</function>' }}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if loop.first or (messages[loop.index0 - 1].role != "tool") %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {%- if message.content is string %}
+            {{- content }}
+        {%- else %}
+            {{- message.content | tojson(ensure_ascii=False) }}
+        {%- endif %}
+        {{- '\n</tool_response>' }}
+        {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+    {%- if enable_thinking is defined %}
+        {%- if enable_thinking is false %}
+            {{- '<think>\n\n</think>\n\n' }}
+        {%- elif enable_thinking is true %}
+            {{- '<think>\n' }}
+        {%- endif %}
+    {%- endif %}
+{%- endif %}

config.json

@@ -0,0 +1,43 @@
+{
+  "architectures": [
+    "LlamaForCausalLM"
+  ],
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "bos_token_id": 0,
+  "dtype": "bfloat16",
+  "eos_token_id": [
+    1,
+    130073
+  ],
+  "head_dim": 128,
+  "hidden_act": "silu",
+  "hidden_size": 2048,
+  "initializer_range": 0.02,
+  "intermediate_size": 6144,
+  "max_position_embeddings": 131072,
+  "mlp_bias": false,
+  "model_type": "llama",
+  "num_attention_heads": 16,
+  "num_hidden_layers": 42,
+  "num_key_value_heads": 2,
+  "pad_token_id": 1,
+  "pretraining_tp": 1,
+  "rms_norm_eps": 1e-06,
+  "rope_parameters": {
+    "rope_theta": 5000000,
+    "rope_type": "default"
+  },
+  "tie_word_embeddings": false,
+  "transformers_version": "5.16.1",
+  "use_cache": true,
+  "vocab_size": 130560,
+  "transformers.js_config": {
+    "kv_cache_dtype": {
+      "q4f16": "float16"
+    },
+    "use_external_data_format": {
+      "model_q4f16.onnx": 2
+    }
+  }
+}

generation_config.json

@@ -0,0 +1,11 @@
+{
+  "_from_model_config": true,
+  "bos_token_id": 0,
+  "eos_token_id": [
+    1,
+    130073
+  ],
+  "pad_token_id": 1,
+  "transformers_version": "5.16.1",
+  "use_cache": true
+}

integration/minicpm5-tool-parser.mjs

@@ -0,0 +1,101 @@
+// MiniCPM5 native XML uses Python literals for typed parameters. No eval/Function.
+export function parseMiniCpmParamValue(input, schema = {}) {
+  const raw = String(input ?? '');
+  const cdata = /^\s*<!\[CDATA\[([\s\S]*?)\]\]>\s*$/.exec(raw);
+  let decoded=cdata ? cdata[1] : raw;
+  if(!cdata) {
+    if(raw.includes('<')) throw Error('Malformed XML parameter: use CDATA for literal markup');
+    decoded=raw.replace(/&(#x[0-9a-f]+|#\d+|amp|lt|gt|quot|apos);/gi,(_,entity)=>{
+      if(entity.startsWith('#')) { const n=entity[1].toLowerCase()==='x'?parseInt(entity.slice(2),16):parseInt(entity.slice(1),10);return String.fromCodePoint(n); }
+      return {amp:'&',lt:'<',gt:'>',quot:'"',apos:"'"}[entity];
+    });
+    if(/&(?!(?:#x[0-9a-f]+|#\d+|amp|lt|gt|quot|apos);)/i.test(raw)) throw Error('Unescaped XML ampersand');
+  }
+  if(schema.type==='string') return decoded;
+  const text = decoded.trim();
+  if (!text) return '';
+  let i = 0;
+  const ws = () => { while (i < text.length && /\s/u.test(text[i])) i++; };
+  const take = char => { ws(); if (text[i++] !== char) throw Error('Invalid literal'); };
+  function value(depth = 0) {
+    if (depth > 32) throw Error('Literal nesting limit');
+    ws();
+    const c = text[i];
+    if (c === "'" || c === '"') {
+      const quote = text[i++]; let result = '';
+      while (i < text.length) {
+        const ch = text[i++];
+        if (ch === quote) return result;
+        if (ch !== '\\') { result += ch; continue; }
+        const e = text[i++];
+        const simple = { '\\':'\\', "'":"'", '"':'"', n:'\n', r:'\r', t:'\t', b:'\b', f:'\f', '/':'/' };
+        if (Object.hasOwn(simple,e)) { result += simple[e]; continue; }
+        const width = e === 'u' ? 4 : e === 'x' ? 2 : 0;
+        const hex = text.slice(i,i+width);
+        if (!width || !new RegExp(`^[a-fA-F0-9]{${width}}$`).test(hex)) throw Error('Invalid escape');
+        result += String.fromCharCode(parseInt(hex,16)); i += width;
+      }
+      throw Error('Unterminated string');
+    }
+    if (c === '[' || c === '{') {
+      i++; const array = c === '['; const end = array ? ']' : '}';
+      const result = array ? [] : Object.create(null);
+      ws(); if (text[i] === end) { i++; return array ? result : {...result}; }
+      while (i < text.length) {
+        if (array) result.push(value(depth+1));
+        else {
+          ws(); if (!['"',"'"].includes(text[i])) throw Error('Expected string key');
+          const key = value(depth+1);
+          if (Object.hasOwn(result,key)) throw Error('Duplicate key');
+          take(':'); result[key] = value(depth+1);
+        }
+        ws(); if (text[i] === end) { i++; return array ? result : {...result}; }
+        take(','); ws();
+        if (text[i] === end) { i++; return array ? result : {...result}; }
+      }
+      throw Error('Unterminated container');
+    }
+    const scalar = /^(True|False|None|true|false|null)(?![\w])/u.exec(text.slice(i));
+    if (scalar) { i += scalar[0].length; return {True:true,False:false,None:null,true:true,false:false,null:null}[scalar[0]]; }
+    const number = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/u.exec(text.slice(i));
+    if (number) { i += number[0].length; const result=Number(number[0]); if(Number.isFinite(result)) return result; }
+    throw Error('Not a literal');
+  }
+  try { const result=value(); ws(); if(i===text.length) return result; } catch { /* native strings are also unquoted */ }
+  return text;
+}
+
+// Strict standalone adapter. Keep downstream tool schema/approval validation in place.
+export function parseMiniCpmToolCalls(text, toolsOrNames) {
+  const tools=Array.isArray(toolsOrNames)?toolsOrNames:[];
+  const allowedNames=Array.isArray(toolsOrNames)?new Set(tools.map(t=>t.function.name)):toolsOrNames;
+  const schemas=new Map(tools.map(t=>[t.function.name,t.function.parameters || {}]));
+  const source=String(text ?? '').trim();
+  if (!source || source.length>10000 || !(allowedNames instanceof Set)) return [];
+  // Native MiniCPM may explain an error before emitting the XML tool call.
+  // Accept that prose, but never skip over a malformed XML call or parameter.
+  const start=source.indexOf('<function');
+  if(start<0 || /<\/?(?:function|param)\b/.test(source.slice(0,start))) return [];
+  const calls=[]; let cursor=start;
+  const functions=/<function\s+name=["']([A-Za-z_]\w*)["']\s*>([\s\S]*?)<\/function>/gy;
+  const params=/<param\s+name=["']([A-Za-z_]\w*)["']\s*>([\s\S]*?)<\/param>/gy;
+  while(cursor<source.length) {
+    while (/\s/u.test(source[cursor] || '')) cursor++;
+    if(cursor===source.length) break;
+    functions.lastIndex=cursor; const fn=functions.exec(source);
+    if(!fn || !allowedNames.has(fn[1])) return [];
+    const args=Object.create(null); let pos=0;
+    while(pos<fn[2].length) {
+      while(/\s/u.test(fn[2][pos] || '')) pos++;
+      if(pos===fn[2].length) break;
+      params.lastIndex=pos; const param=params.exec(fn[2]);
+      if(!param || Object.hasOwn(args,param[1])) return [];
+      try { args[param[1]]=parseMiniCpmParamValue(param[2],schemas.get(fn[1])?.properties?.[param[1]]); }
+      catch { return []; }
+      pos=params.lastIndex;
+    }
+    calls.push({id:`compass_call_${Date.now()}_${calls.length}`,type:'function',function:{name:fn[1],arguments:JSON.stringify(args)}});
+    cursor=functions.lastIndex;
+  }
+  return calls;
+}

integration/parser.test.mjs

@@ -0,0 +1,40 @@
+// Portable CPU-only checks for the separately audited optional helper.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {parseMiniCpmParamValue as parse, parseMiniCpmToolCalls as calls} from './minicpm5-tool-parser.mjs';
+
+const tools = [{type: 'function', function: {name: 'save_labels', parameters: {
+  type: 'object', properties: {labels: {type: 'array', items: {type: 'string'}}, enabled: {type: 'boolean'}},
+}}}];
+const xml = '<function name="save_labels"><param name="labels">[\'green\', \'amber\']</param><param name="enabled">False</param></function>';
+
+test('v24 native list and boolean keep their argument types', () => {
+  assert.deepEqual(JSON.parse(calls(xml, tools)[0].function.arguments), {labels: ['green', 'amber'], enabled: false});
+});
+test('CDATA URL and string-typed JSON stay strings', () => {
+  assert.equal(parse('<![CDATA[https://example.net/find?name=blue&sort=recent]]>', {type: 'string'}), 'https://example.net/find?name=blue&sort=recent');
+  assert.equal(parse('{"message":""}', {type: 'string'}), '{"message":""}');
+});
+test('unknown tool names and mixed unknown batches are rejected', () => {
+  const unknown = '<function name="unprovided_tool"></function>';
+  assert.deepEqual(calls(unknown, tools), []);
+  assert.deepEqual(calls(xml + unknown, tools), []);
+  assert.deepEqual(calls(xml, []), []);
+});
+test('malformed and duplicate native fields are not repaired', () => {
+  assert.deepEqual(calls(xml.replace('</function>', ''), tools), []);
+  assert.deepEqual(calls(xml.replace('</function>', '<param name="enabled">True</param></function>'), tools), []);
+  assert.deepEqual(calls(xml + 'garbage', tools), []);
+});
+test('nested literals do not evaluate code or pollute prototypes', () => {
+  assert.deepEqual(parse("{'flag': True, 'next': None, 'xs': [1, 2.5]}"), {flag: true, next: null, xs: [1, 2.5]});
+  assert.equal(parse("['x', dangerous()]"), "['x', dangerous()]");
+  assert.equal(parse('True + exec()'), 'True + exec()');
+  parse("{'__proto__': {'polluted': True}}");
+  assert.equal(Object.prototype.polluted, undefined);
+});
+test('zero-argument native functions remain valid', () => {
+  const result = calls('<function name="get_accessibility_tree"></function>', new Set(['get_accessibility_tree']));
+  assert.equal(result.length, 1);
+  assert.deepEqual(JSON.parse(result[0].function.arguments), {});
+});

onnx/model_q4f16.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ab10bc051ca80ad6dffe5045acac030d0d6b75c52d90db363d044f1f214fccfa
+size 362892

onnx/model_q4f16.onnx_data

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2abad6aebb250a04619df22e8b2cab9998ee92ba083ec5426c97ae1beb8476f7
+size 1596739584

onnx/model_q4f16.onnx_data_1

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:715887fa2ce24f2f1d5f5f8adaebc0caac4bad02e7d4d90e081f85decefec244
+size 272252928

runtime/inference-worker.js

@@ -0,0 +1,1539 @@
+/**
+ * Dedicated WebGPU worker for endpoint-free local model inference.
+ *
+ * WebGPU is unavailable in the MV3 service worker, and large ONNX allocations
+ * are more reliable in a dedicated worker than on the offscreen document's
+ * main thread. The offscreen host owns this worker and proxies correlated
+ * request/response messages to it.
+ */
+
+let libraryPromise = null;
+let libraryVersion = null;
+let workerConfig = null;
+let visionRuntime = null;
+let visionRuntimeKey = '';
+let visionRuntimeModelKey = '';
+let visionRuntimeOwner = '';
+let visionRuntimeLoadPromise = null;
+let visionRuntimeLoadKey = '';
+let textRuntime = null;
+let textRuntimeKey = '';
+let textRuntimeModelKey = '';
+let textRuntimeLoadPromise = null;
+let textRuntimeLoadKey = '';
+let modelOperationQueue = Promise.resolve();
+const TRANSFORMERS_CACHE_NAME = 'transformers-cache';
+const TEXT_DOWNLOAD_EVENT = 'text-download-state';
+const WEBGPU_TEXT_MAX_NEW_TOKENS = 256;
+const WEBGPU_LFM25_MODEL_ID = 'LiquidAI/LFM2.5-2.6B-ONNX';
+const WEBGPU_LFM25_12B_INSTRUCT_MODEL_ID = 'LiquidAI/LFM2.5-1.2B-Instruct-ONNX';
+const WEBGPU_LFM25_12B_THINKING_MODEL_ID = 'LiquidAI/LFM2.5-1.2B-Thinking-ONNX';
+const WEBGPU_LFM25_VL_16B_MODEL_ID = 'LiquidAI/LFM2.5-VL-1.6B-ONNX';
+const WEBGPU_LFM25_VL_3B_MODEL_ID = 'LiquidAI/LFM2.5-VL-3B-ONNX';
+const WEBGPU_NANBEIGE42_3B_MODEL_ID = 'Michionlion/Nanbeige4.2-3B-ONNX-WebGPU';
+const WEBGPU_MINICPM5_2B_MODEL_ID = 'RASMUS/MiniCPM5-2B-ONNX';
+const WEBGPU_BONSAI27_MODEL_ID = 'prism-ml/Bonsai-27B-gguf';
+const WEBGPU_LFM25_MAX_NEW_TOKENS = 2048;
+const WEBGPU_LFM25_TEXT_MODEL_IDS = new Set([
+  WEBGPU_LFM25_MODEL_ID,
+  WEBGPU_LFM25_12B_INSTRUCT_MODEL_ID,
+  WEBGPU_LFM25_12B_THINKING_MODEL_ID,
+]);
+const WEBGPU_LFM25_VL_MODEL_IDS = new Set([
+  WEBGPU_LFM25_VL_16B_MODEL_ID,
+  WEBGPU_LFM25_VL_3B_MODEL_ID,
+]);
+// Presets whose reasoning is generated as hidden thinking rather than as part
+// of the visible answer, so they need the long output budget.
+const WEBGPU_REASONING_MODEL_IDS = new Set([
+  WEBGPU_LFM25_MODEL_ID,
+  WEBGPU_LFM25_12B_THINKING_MODEL_ID,
+  WEBGPU_NANBEIGE42_3B_MODEL_ID,
+  WEBGPU_MINICPM5_2B_MODEL_ID,
+]);
+// Chat templates that emit the opening `<think>` themselves, so the runtime
+// only returns the reasoning suffix.
+const WEBGPU_OPEN_THINKING_MODEL_IDS = new Set([
+  WEBGPU_LFM25_MODEL_ID,
+  WEBGPU_NANBEIGE42_3B_MODEL_ID,
+]);
+const WEBGPU_LONG_OUTPUT_MODEL_IDS = new Set([
+  ...WEBGPU_LFM25_TEXT_MODEL_IDS,
+  WEBGPU_NANBEIGE42_3B_MODEL_ID,
+  WEBGPU_MINICPM5_2B_MODEL_ID,
+]);
+// Publisher-recommended decoding for the shipped reasoning presets. Custom
+// repositories keep Transformers.js greedy defaults.
+const WEBGPU_TEXT_SAMPLING = new Map([
+  [WEBGPU_LFM25_MODEL_ID, { temperature: 0.1, top_k: 50, repetition_penalty: 1.1 }],
+  [WEBGPU_LFM25_12B_THINKING_MODEL_ID, { temperature: 0.05, top_k: 50, repetition_penalty: 1.05 }],
+  // Nanbeige4.2-3B's own generation_config.json.
+  [WEBGPU_NANBEIGE42_3B_MODEL_ID, { temperature: 0.6, top_k: 20, top_p: 0.95 }],
+  // MiniCPM5-2B quickstart: temperature=1.0, top_p=0.95.
+  [WEBGPU_MINICPM5_2B_MODEL_ID, { temperature: 1.0, top_p: 0.95 }],
+]);
+// Nanbeige ships a single WebGPU-fused graph under a non-default file name.
+// Without this override Transformers.js looks for `onnx/model_q4f16.onnx`,
+// which the repository does not publish.
+const WEBGPU_TEXT_MODEL_FILE_NAMES = new Map([
+  [WEBGPU_NANBEIGE42_3B_MODEL_ID, 'model_webgpu_mlp'],
+]);
+const WEBGPU_VISION_READY_MARKER_VERSION = 2;
+const WEBGPU_VISION_READY_MARKER_PREFIX = 'https://webbrain.one/.well-known/webgpu-vision-ready/';
+function createWebGpuTextSessionOptions() {
+  return {
+    extra: {
+      // ORT's default bucket cache can retain rounded-up transient buffers. That
+      // is especially costly for dynamic prefill/decode shapes on Metal.
+      'ep.webgpuexecutionprovider.storageBufferCacheMode': 'simple',
+    },
+  };
+}
+const readyTextModelKeys = new Set();
+const textDownloadFiles = new Map();
+const nativeFetch = typeof globalThis.fetch === 'function' ? globalThis.fetch.bind(globalThis) : null;
+let activeTextDownloadModelId = '';
+let queuedTextDownload = null;
+let textDownloadAbortController = null;
+let textDownloadCancelMode = '';
+let activeVisionDownloadRequest = null;
+let queuedVisionDownload = null;
+let visionDownloadAbortController = null;
+const activeVisionGenerations = new Map();
+const queuedVisionGenerations = new Set();
+const cancelledVisionGenerations = new Set();
+let lastTextProgressPostAt = 0;
+let webGpuAdapterProbePromise = null;
+let webGpuAdapterSummary = '';
+let observedWebGpuDevice = null;
+let lastWebGpuDeviceError = '';
+let lastWebGpuDeviceLost = '';
+let textDownloadState = {
+  status: 'not-downloaded',
+  ready: false,
+  modelId: '',
+  dtype: '',
+  file: '',
+  loaded: 0,
+  total: 0,
+  progress: 0,
+  error: '',
+};
+
+function textDtypeKey(dtype) {
+  if (!dtype || typeof dtype !== 'object' || Array.isArray(dtype)) return String(dtype || '').trim();
+  return JSON.stringify(Object.fromEntries(
+    Object.entries(dtype).sort(([left], [right]) => left.localeCompare(right)),
+  ));
+}
+
+function textModelKey(modelId, dtype) {
+  return `${String(modelId || '').trim()}|${textDtypeKey(dtype)}`;
+}
+
+function sameTextModel(leftModelId, leftDtype, rightModelId, rightDtype) {
+  return textModelKey(leftModelId, leftDtype) === textModelKey(rightModelId, rightDtype);
+}
+
+function assertOnnxTextModel(modelId) {
+  const normalized = String(modelId || '').trim();
+  if (!normalized) throw new Error('No text-generation model was specified.');
+  if (normalized === WEBGPU_BONSAI27_MODEL_ID || /\.gguf$/i.test(normalized)) {
+    throw new Error(`${normalized} is a GGUF checkpoint and cannot be loaded with Transformers.js. Use the Bonsai WebGPU runtime.`);
+  }
+  return normalized;
+}
+
+function isLfm25VlModel(modelId) {
+  return WEBGPU_LFM25_VL_MODEL_IDS.has(String(modelId || '').trim());
+}
+
+function lfm25VlProcessorOptions(modelId) {
+  if (!isLfm25VlModel(modelId)) return {};
+  return {
+    // LiquidAI's current VL ONNX repos use the Transformers v5 layout: image
+    // settings are nested in processor_config.json and the chat template is a
+    // separate Jinja file. The packaged Transformers.js 4.2 runtime supports
+    // both through WebBrain's documented browser-bundle compatibility hooks.
+    image_processor_config_file: 'processor_config.json',
+    chat_template_file: 'chat_template.jinja',
+  };
+}
+
+function assertTextDownloadCanStart(payload) {
+  const modelId = assertOnnxTextModel(payload?.modelId);
+  const dtype = payload?.dtype || 'q4f16';
+  const conflictsWithTransfer = textDownloadState.modelId
+    && !sameTextModel(textDownloadState.modelId, textDownloadState.dtype, modelId, dtype)
+    && ['downloading', 'paused', 'stopping'].includes(textDownloadState.status);
+  const conflictsWithQueued = queuedTextDownload
+    && !sameTextModel(queuedTextDownload.modelId, queuedTextDownload.dtype, modelId, dtype);
+  if (conflictsWithTransfer || conflictsWithQueued) {
+    const blockingModel = conflictsWithTransfer ? textDownloadState.modelId : queuedTextDownload.modelId;
+    throw new Error(`Finish or stop the ${blockingModel} download before downloading ${modelId}.`);
+  }
+  return { modelId, dtype, key: textModelKey(modelId, dtype) };
+}
+
+function textReadyMarkerUrl(modelId, dtype) {
+  const key = encodeURIComponent(textModelKey(modelId, dtype));
+  return `https://webbrain.one/.well-known/webgpu-model-ready/${key}`;
+}
+
+function safeDecodedUrl(value) {
+  try { return decodeURIComponent(String(value || '')); } catch { return String(value || ''); }
+}
+
+function fetchTargetsActiveTextModel(input) {
+  if (!activeTextDownloadModelId) return false;
+  const url = typeof input === 'string' || input instanceof URL ? String(input) : input?.url;
+  return safeDecodedUrl(url).includes(`/${activeTextDownloadModelId}/`);
+}
+
+function fetchTargetsActiveVisionModel(input) {
+  if (!activeVisionDownloadRequest?.modelId) return false;
+  const url = typeof input === 'string' || input instanceof URL ? String(input) : input?.url;
+  return safeDecodedUrl(url).includes(`/${activeVisionDownloadRequest.modelId}/`);
+}
+
+function visionReadyMarkerUrl(modelId) {
+  return `${WEBGPU_VISION_READY_MARKER_PREFIX}v${WEBGPU_VISION_READY_MARKER_VERSION}/${encodeURIComponent(String(modelId || '').trim())}`;
+}
+
+function isVisionReadyMarkerForModel(url, modelId) {
+  const candidate = String(url || '');
+  const encodedModelId = encodeURIComponent(String(modelId || '').trim());
+  return candidate.startsWith(WEBGPU_VISION_READY_MARKER_PREFIX)
+    && candidate.endsWith(`/${encodedModelId}`);
+}
+
+async function isVisionModelCached(modelId) {
+  const normalized = String(modelId || '').trim();
+  if (!normalized) return false;
+  if (typeof caches === 'undefined') return null;
+  const markerUrl = visionReadyMarkerUrl(normalized);
+  try {
+    for (const name of await caches.keys()) {
+      if (!/transformers/i.test(name)) continue;
+      const cache = await caches.open(name);
+      if (await cache.match(markerUrl)) return true;
+    }
+  } catch {
+    return null;
+  }
+  return false;
+}
+
+async function markVisionModelReady(modelId) {
+  const normalized = String(modelId || '').trim();
+  if (!normalized || typeof caches === 'undefined') return;
+  const cache = await caches.open(TRANSFORMERS_CACHE_NAME);
+  await cache.put(visionReadyMarkerUrl(normalized), new Response(JSON.stringify({
+    modelId: normalized,
+    markerVersion: WEBGPU_VISION_READY_MARKER_VERSION,
+  }), {
+    headers: { 'content-type': 'application/json' },
+  }));
+}
+
+async function controlledFetch(input, init = {}) {
+  if (!nativeFetch) throw new Error('Fetch is unavailable in the WebGPU worker.');
+  if (textDownloadAbortController && fetchTargetsActiveTextModel(input)) {
+    return nativeFetch(input, { ...init, signal: textDownloadAbortController.signal });
+  }
+  if (visionDownloadAbortController && fetchTargetsActiveVisionModel(input)) {
+    return nativeFetch(input, { ...init, signal: visionDownloadAbortController.signal });
+  }
+  return nativeFetch(input, init);
+}
+
+function textDownloadSnapshot() {
+  return { ...textDownloadState };
+}
+
+function postTextDownloadState({ force = false } = {}) {
+  const now = Date.now();
+  if (!force && now - lastTextProgressPostAt < 160) return;
+  lastTextProgressPostAt = now;
+  self.postMessage({ type: TEXT_DOWNLOAD_EVENT, state: textDownloadSnapshot() });
+}
+
+async function isTextModelReady(modelId, dtype) {
+  const key = textModelKey(modelId, dtype);
+  if (readyTextModelKeys.has(key)) return true;
+  if (typeof caches === 'undefined') return false;
+  try {
+    const cache = await caches.open(TRANSFORMERS_CACHE_NAME);
+    const marker = await cache.match(textReadyMarkerUrl(modelId, dtype));
+    if (!marker) return false;
+    readyTextModelKeys.add(key);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function markTextModelReady(modelId, dtype) {
+  const key = textModelKey(modelId, dtype);
+  if (typeof caches === 'undefined') {
+    readyTextModelKeys.add(key);
+    return;
+  }
+  const cache = await caches.open(TRANSFORMERS_CACHE_NAME);
+  await cache.put(textReadyMarkerUrl(modelId, dtype), new Response(JSON.stringify({ modelId, dtype }), {
+    headers: { 'content-type': 'application/json' },
+  }));
+  readyTextModelKeys.add(key);
+}
+
+async function loadLibrary() {
+  if (libraryPromise) return libraryPromise;
+  if (!workerConfig) throw new Error('WebGPU worker was not initialized.');
+  libraryPromise = (async () => {
+    let library;
+    try {
+      library = await import(workerConfig.transformersUrl);
+    } catch (error) {
+      libraryPromise = null;
+      throw new Error(`The packaged Transformers.js runtime could not be loaded: ${error?.message || error}`);
+    }
+    libraryVersion = library.env?.version || library.VERSION || 'unknown';
+    if (library.env) {
+      library.env.allowLocalModels = false;
+      library.env.allowRemoteModels = true;
+      library.env.useBrowserCache = true;
+      library.env.useWasmCache = false;
+      library.env.fetch = controlledFetch;
+      const wasm = library.env.backends?.onnx?.wasm;
+      if (wasm) {
+        wasm.numThreads = 1;
+        wasm.wasmPaths = {
+          mjs: workerConfig.wasmMjsUrl,
+          wasm: workerConfig.wasmUrl,
+        };
+      }
+    }
+    return library;
+  })();
+  return libraryPromise;
+}
+
+function compactAdapterInfo(adapter) {
+  if (!adapter) return '';
+  const info = adapter.info || {};
+  const identity = [info.vendor, info.architecture, info.device, info.description]
+    .map(value => String(value || '').trim())
+    .filter((value, index, values) => value && values.indexOf(value) === index)
+    .join(' / ');
+  const maxBufferSize = Number(adapter.limits?.maxBufferSize);
+  const maxStorageBinding = Number(adapter.limits?.maxStorageBufferBindingSize);
+  const limits = [
+    Number.isFinite(maxBufferSize) ? `maxBufferSize=${maxBufferSize}` : '',
+    Number.isFinite(maxStorageBinding) ? `maxStorageBufferBindingSize=${maxStorageBinding}` : '',
+  ].filter(Boolean).join(', ');
+  return [identity, limits].filter(Boolean).join('; ');
+}
+
+async function captureWebGpuAdapterSummary() {
+  if (webGpuAdapterProbePromise) return webGpuAdapterProbePromise;
+  webGpuAdapterProbePromise = (async () => {
+    if (typeof navigator === 'undefined' || !navigator.gpu) return '';
+    try {
+      const adapter = await navigator.gpu.requestAdapter({ powerPreference: 'high-performance' });
+      webGpuAdapterSummary = compactAdapterInfo(adapter);
+    } catch {}
+    return webGpuAdapterSummary;
+  })();
+  return webGpuAdapterProbePromise;
+}
+
+function bindWebGpuDeviceDiagnostics(library) {
+  const device = library?.env?.backends?.onnx?.webgpu?.device;
+  if (!device || device === observedWebGpuDevice) return;
+  observedWebGpuDevice = device;
+  lastWebGpuDeviceError = '';
+  lastWebGpuDeviceLost = '';
+  device.addEventListener?.('uncapturederror', event => {
+    lastWebGpuDeviceError = String(event?.error?.message || event?.message || 'Unknown WebGPU validation error.');
+    console.error('[webgpu] uncaptured device error:', lastWebGpuDeviceError);
+  });
+  device.lost?.then(info => {
+    if (device !== observedWebGpuDevice) return;
+    lastWebGpuDeviceLost = String(info?.message || info?.reason || 'The WebGPU device was lost.');
+    console.error('[webgpu] device lost:', lastWebGpuDeviceLost);
+  }).catch(() => {});
+}
+
+function isWebGpuExecutionFailure(error) {
+  return /OrtRun|BufferManager::Download|mapAsync|GPUBuffer|device lost/i.test(error?.message || String(error));
+}
+
+async function enrichWebGpuExecutionError(error) {
+  // WebGPU uncaptured-error/device-lost events can arrive just after OrtRun's
+  // generic buffer readback exception. Give that event one task to land so the
+  // user sees the actionable root error instead of only "Invalid Buffer".
+  await new Promise(resolve => setTimeout(resolve, 0));
+  const details = [lastWebGpuDeviceError, lastWebGpuDeviceLost]
+    .map(value => String(value || '').trim())
+    .filter((value, index, values) => value && values.indexOf(value) === index);
+  const adapter = webGpuAdapterSummary || await captureWebGpuAdapterSummary();
+  const suffix = [
+    details.length ? `GPU detail: ${details.join(' ')}` : '',
+    adapter ? `Adapter: ${adapter}.` : '',
+    'Close other GPU-heavy tabs/apps and retry with a short prompt. If it persists, this GPU/driver cannot execute this model with the current WebGPU runtime.',
+  ].filter(Boolean).join(' ');
+  return new Error(`${error?.message || String(error)} ${suffix}`);
+}
+
+function postProgress(modelId, event) {
+  if (modelId === activeTextDownloadModelId && !textDownloadCancelMode) {
+    const file = String(event?.file || event?.name || '');
+    if (file) {
+      const previous = textDownloadFiles.get(file) || { loaded: 0, total: 0, status: '' };
+      const total = Number(event?.total || previous.total || 0);
+      const loaded = event?.status === 'done' && total > 0
+        ? total
+        : Number(event?.loaded ?? previous.loaded ?? 0);
+      textDownloadFiles.set(file, {
+        status: event?.status || previous.status,
+        loaded: Math.max(0, loaded),
+        total: Math.max(0, total),
+      });
+    }
+    let loaded = 0;
+    let total = 0;
+    for (const item of textDownloadFiles.values()) {
+      if (item.total <= 0) continue;
+      loaded += Math.min(item.loaded, item.total);
+      total += item.total;
+    }
+    textDownloadState = {
+      ...textDownloadState,
+      status: 'downloading',
+      ready: false,
+      file,
+      loaded,
+      total,
+      progress: total > 0 ? Math.max(0, Math.min(100, loaded / total * 100)) : 0,
+      error: '',
+    };
+    postTextDownloadState({ force: event?.status === 'done' });
+  }
+  self.postMessage({
+    type: 'progress',
+    modelId,
+    status: event?.status || '',
+    file: event?.file || event?.name || '',
+    loaded: Number(event?.loaded || 0),
+    total: Number(event?.total || 0),
+    progress: Number(event?.progress || 0),
+  });
+}
+
+async function disposeRuntime(runtime) {
+  if (runtime?.pipeline?.dispose) {
+    try { await runtime.pipeline.dispose(); } catch {}
+  } else if (runtime?.model?.dispose) {
+    try { await runtime.model.dispose(); } catch {}
+  }
+  if (runtime?.processor?.dispose) {
+    try { await runtime.processor.dispose(); } catch {}
+  }
+}
+
+async function disposeVisionRuntime(expectedOwner = '') {
+  if (expectedOwner && visionRuntimeOwner && visionRuntimeOwner !== expectedOwner) return;
+  const runtime = visionRuntime;
+  visionRuntime = null;
+  visionRuntimeKey = '';
+  visionRuntimeModelKey = '';
+  visionRuntimeOwner = '';
+  await disposeRuntime(runtime);
+}
+
+async function disposeTextRuntime() {
+  const runtime = textRuntime;
+  textRuntime = null;
+  textRuntimeKey = '';
+  textRuntimeModelKey = '';
+  await disposeRuntime(runtime);
+}
+
+async function disposeAllRuntimes() {
+  await disposeVisionRuntime();
+  await disposeTextRuntime();
+}
+
+async function legacyLfm25VlConfig(library, modelId, progress_callback, localFilesOnly) {
+  if (modelId !== WEBGPU_LFM25_VL_16B_MODEL_ID) return null;
+  if (!library.AutoConfig) {
+    throw new Error('The packaged Transformers.js version cannot load the LFM2.5-VL-1.6B model config.');
+  }
+  const config = await library.AutoConfig.from_pretrained(modelId, {
+    progress_callback,
+    local_files_only: localFilesOnly,
+  });
+  config['transformers.js_config'] = {
+    ...(config['transformers.js_config'] || {}),
+    // LiquidAI's 1.6B ONNX export predates the standard Transformers.js
+    // ImageTextToText filenames used by the newer 3B package.
+    session_file_names: {
+      embed_tokens: 'embed_tokens',
+      vision_encoder: 'embed_images',
+      decoder_model_merged: 'decoder',
+    },
+    use_external_data_format: {
+      'embed_tokens_fp16.onnx': 1,
+      'embed_images_fp16.onnx': 1,
+      'decoder_q4.onnx': 1,
+    },
+  };
+  return config;
+}
+
+async function getVisionRuntime(modelId, dtype, device, {
+  localFilesOnly = false,
+  owner = 'vision',
+  readiness = 'vision',
+} = {}) {
+  const key = `vision|${modelId}|${device}|${JSON.stringify(dtype)}`;
+  if (visionRuntime && visionRuntimeKey === key) {
+    visionRuntimeOwner = owner;
+    return visionRuntime;
+  }
+  if (visionRuntimeLoadPromise) {
+    if (visionRuntimeLoadKey === key) return visionRuntimeLoadPromise;
+    await visionRuntimeLoadPromise.catch(() => {});
+    if (visionRuntime && visionRuntimeKey === key) {
+      visionRuntimeOwner = owner;
+      return visionRuntime;
+    }
+  }
+
+  const loadPromise = (async () => {
+    const locallyReady = readiness === 'text'
+      ? await isTextModelReady(modelId, dtype)
+      : await isVisionModelCached(modelId);
+    if (localFilesOnly && locallyReady === false) {
+      const error = new Error(`${modelId} is not cached locally.`);
+      error.code = readiness === 'text' ? 'text_model_not_downloaded' : 'vision_model_not_downloaded';
+      throw error;
+    }
+    const library = await loadLibrary();
+    const { AutoModelForImageTextToText, AutoProcessor } = library;
+    if (!AutoModelForImageTextToText || !AutoProcessor) {
+      throw new Error('The packaged Transformers.js version does not include image-text-to-text support.');
+    }
+    if (owner === 'text') await disposeTextRuntime();
+    await disposeVisionRuntime();
+    const progress_callback = event => postProgress(modelId, event);
+    const config = await legacyLfm25VlConfig(library, modelId, progress_callback, localFilesOnly);
+    const processorOptions = lfm25VlProcessorOptions(modelId);
+    const previousAllowLocalModels = library.env?.allowLocalModels;
+    if (localFilesOnly && library.env) library.env.allowLocalModels = true;
+    let processorResult;
+    let modelResult;
+    try {
+      [processorResult, modelResult] = await Promise.allSettled([
+        AutoProcessor.from_pretrained(modelId, {
+          ...processorOptions,
+          progress_callback,
+          local_files_only: localFilesOnly,
+        }),
+        AutoModelForImageTextToText.from_pretrained(modelId, {
+          device,
+          dtype,
+          ...(config ? { config } : {}),
+          progress_callback,
+          local_files_only: localFilesOnly,
+        }),
+      ]);
+    } finally {
+      if (localFilesOnly && library.env) library.env.allowLocalModels = previousAllowLocalModels;
+    }
+    if (processorResult.status === 'rejected' || modelResult.status === 'rejected') {
+      const loaded = [processorResult, modelResult]
+        .filter(result => result.status === 'fulfilled')
+        .map(result => result.value);
+      for (const resource of loaded) {
+        if (resource?.dispose) {
+          try { await resource.dispose(); } catch {}
+        }
+      }
+      throw processorResult.status === 'rejected'
+        ? processorResult.reason
+        : modelResult.reason;
+    }
+    const processor = processorResult.value;
+    const model = modelResult.value;
+    visionRuntime = { library, processor, model };
+    visionRuntimeKey = key;
+    visionRuntimeModelKey = textModelKey(modelId, dtype);
+    visionRuntimeOwner = owner;
+    return visionRuntime;
+  })();
+  visionRuntimeLoadPromise = loadPromise;
+  visionRuntimeLoadKey = key;
+  try {
+    return await loadPromise;
+  } finally {
+    if (visionRuntimeLoadPromise === loadPromise) {
+      visionRuntimeLoadPromise = null;
+      visionRuntimeLoadKey = '';
+    }
+  }
+}
+
+async function preloadRuntime(payload = {}) {
+  const modelId = String(payload.modelId || '').trim();
+  if (!modelId) throw new Error('No vision model was specified.');
+  const device = payload.device || 'webgpu';
+  const dtype = payload.dtype || {
+    embed_tokens: 'fp16',
+    vision_encoder: 'fp16',
+    decoder_model_merged: 'q4',
+  };
+  await getVisionRuntime(modelId, dtype, device);
+  await disposeVisionRuntime();
+  return modelId;
+}
+
+function visionDownloadState(request, status) {
+  return {
+    status,
+    ready: status === 'ready',
+    modelId: request?.modelId || '',
+    dtype: request?.dtype || '',
+  };
+}
+
+async function preloadVisionModel(payload, request) {
+  if (queuedVisionDownload !== request || request.cancelMode) {
+    return visionDownloadState(request, request.cancelMode === 'stop' ? 'not-downloaded' : 'paused');
+  }
+  queuedVisionDownload = null;
+  activeVisionDownloadRequest = request;
+  const controller = new AbortController();
+  visionDownloadAbortController = controller;
+  try {
+    await preloadRuntime(payload);
+    const status = request.cancelMode === 'stop'
+      ? 'not-downloaded'
+      : request.cancelMode === 'pause' ? 'paused' : 'ready';
+    if (status === 'ready') await markVisionModelReady(request.modelId);
+    return visionDownloadState(request, status);
+  } catch (error) {
+    if (request.cancelMode || controller.signal.aborted) {
+      return visionDownloadState(request, request.cancelMode === 'stop' ? 'not-downloaded' : 'paused');
+    }
+    throw error;
+  } finally {
+    if (visionDownloadAbortController === controller) visionDownloadAbortController = null;
+    if (activeVisionDownloadRequest === request) activeVisionDownloadRequest = null;
+  }
+}
+
+function pauseVisionDownload(modelId) {
+  const normalizedModelId = String(modelId || '').trim();
+  const queued = queuedVisionDownload;
+  const active = activeVisionDownloadRequest;
+  const targetQueued = queued && (!normalizedModelId || queued.modelId === normalizedModelId);
+  const targetActive = active && (!normalizedModelId || active.modelId === normalizedModelId);
+  if (targetQueued) {
+    queued.cancelMode = 'pause';
+    if (queuedVisionDownload === queued) queuedVisionDownload = null;
+  }
+  if (targetActive) {
+    active.cancelMode = 'pause';
+    visionDownloadAbortController?.abort();
+  }
+  const target = targetActive ? active : targetQueued ? queued : { modelId: normalizedModelId };
+  return {
+    ...visionDownloadState(target, 'paused'),
+    targetsQueued: Boolean(targetQueued),
+    targetsActive: Boolean(targetActive),
+  };
+}
+
+function stopVisionDownload(modelId) {
+  const normalizedModelId = String(modelId || '').trim();
+  const queued = queuedVisionDownload;
+  const active = activeVisionDownloadRequest;
+  const targetsQueued = Boolean(queued && (!normalizedModelId || queued.modelId === normalizedModelId));
+  const targetsActive = Boolean(active && (!normalizedModelId || active.modelId === normalizedModelId));
+  if (targetsQueued) {
+    queued.cancelMode = 'stop';
+    if (queuedVisionDownload === queued) queuedVisionDownload = null;
+  }
+  if (targetsActive) {
+    active.cancelMode = 'stop';
+    visionDownloadAbortController?.abort();
+  }
+  return { targetsQueued, targetsActive, hasActiveVision: Boolean(active) };
+}
+
+async function getTextRuntime(modelId, dtype, device, { localFilesOnly = false } = {}) {
+  assertOnnxTextModel(modelId);
+  const key = `text|${modelId}|${device}|${JSON.stringify(dtype)}`;
+  if (textRuntime && textRuntimeKey === key) return textRuntime;
+  if (textRuntimeLoadPromise) {
+    if (textRuntimeLoadKey === key) return textRuntimeLoadPromise;
+    await textRuntimeLoadPromise.catch(() => {});
+    if (textRuntime && textRuntimeKey === key) return textRuntime;
+  }
+
+  const loadPromise = (async () => {
+    const library = await loadLibrary();
+    if (!library.pipeline) {
+      throw new Error('The packaged Transformers.js version does not include text generation.');
+    }
+    await captureWebGpuAdapterSummary();
+    await disposeVisionRuntime('text');
+    await disposeTextRuntime();
+    const previousAllowLocalModels = library.env?.allowLocalModels;
+    if (localFilesOnly && library.env) library.env.allowLocalModels = true;
+    let pipeline;
+    try {
+      pipeline = await library.pipeline('text-generation', modelId, {
+        device,
+        dtype,
+        ...(WEBGPU_TEXT_MODEL_FILE_NAMES.has(modelId)
+          ? { model_file_name: WEBGPU_TEXT_MODEL_FILE_NAMES.get(modelId) }
+          : {}),
+        // ORT mutates this object while appending its default session config.
+        session_options: createWebGpuTextSessionOptions(),
+        local_files_only: localFilesOnly,
+        progress_callback: event => postProgress(modelId, event),
+      });
+    } finally {
+      if (localFilesOnly && library.env) library.env.allowLocalModels = previousAllowLocalModels;
+    }
+    bindWebGpuDeviceDiagnostics(library);
+    textRuntime = {
+      library,
+      pipeline,
+      model: pipeline.model,
+      tokenizer: pipeline.tokenizer,
+    };
+    textRuntimeKey = key;
+    textRuntimeModelKey = textModelKey(modelId, dtype);
+    return textRuntime;
+  })();
+  textRuntimeLoadPromise = loadPromise;
+  textRuntimeLoadKey = key;
+  try {
+    return await loadPromise;
+  } finally {
+    if (textRuntimeLoadPromise === loadPromise) {
+      textRuntimeLoadPromise = null;
+      textRuntimeLoadKey = '';
+    }
+  }
+}
+
+async function getDownloadedTextRuntime(modelId, dtype, device, { localFilesOnly = false } = {}) {
+  if (isLfm25VlModel(modelId)) {
+    return getVisionRuntime(modelId, dtype, device, {
+      localFilesOnly,
+      owner: 'text',
+      readiness: 'text',
+    });
+  }
+  return getTextRuntime(modelId, dtype, device, { localFilesOnly });
+}
+
+async function disposeDownloadedTextRuntime(modelId = '') {
+  if (!modelId || isLfm25VlModel(modelId)) await disposeVisionRuntime('text');
+  if (!modelId || !isLfm25VlModel(modelId)) await disposeTextRuntime();
+}
+
+function chatTemplateText(value) {
+  if (typeof value === 'string') return value;
+  if (Array.isArray(value)) return value.map(chatTemplateText).join('\n');
+  if (value && typeof value === 'object') return Object.values(value).map(chatTemplateText).join('\n');
+  return '';
+}
+
+export function tokenizerSupportsTools(tokenizer) {
+  const template = chatTemplateText(tokenizer?.chat_template ?? tokenizer?.chatTemplate);
+  return /\btools\b/.test(template);
+}
+
+function assertToolCapableTextRuntime(runtime, modelId) {
+  if (tokenizerSupportsTools(runtime?.tokenizer)) return;
+  throw new Error(`${modelId} is not compatible with WebBrain: custom repositories must provide a chat template that accepts tools.`);
+}
+
+async function getTextDownloadStatus(modelId, dtype) {
+  const ready = await isTextModelReady(modelId, dtype);
+  const sameModel = sameTextModel(textDownloadState.modelId, textDownloadState.dtype, modelId, dtype);
+  if (sameModel && ['downloading', 'paused', 'stopping'].includes(textDownloadState.status)) {
+    return textDownloadSnapshot();
+  }
+  if (ready) {
+    return {
+      status: 'ready',
+      ready: true,
+      modelId,
+      dtype,
+      file: sameModel ? textDownloadState.file : '',
+      loaded: sameModel ? textDownloadState.loaded : 0,
+      total: sameModel ? textDownloadState.total : 0,
+      progress: 100,
+      error: '',
+    };
+  }
+  if (sameModel && textDownloadState.status === 'error') return textDownloadSnapshot();
+  return {
+    status: 'not-downloaded',
+    ready: false,
+    modelId,
+    dtype,
+    file: '',
+    loaded: 0,
+    total: 0,
+    progress: 0,
+    error: '',
+  };
+}
+
+async function downloadTextModel(payload, { onStarted } = {}) {
+  const modelId = assertOnnxTextModel(payload?.modelId);
+  const device = payload?.device || 'webgpu';
+  const dtype = payload?.dtype || 'q4f16';
+  const tracksDifferentTransfer = textDownloadState.modelId
+    && !sameTextModel(textDownloadState.modelId, textDownloadState.dtype, modelId, dtype)
+    && ['downloading', 'paused', 'stopping'].includes(textDownloadState.status);
+  if (tracksDifferentTransfer) {
+    throw new Error(`Finish or stop the ${textDownloadState.modelId} download before downloading ${modelId}.`);
+  }
+  await clearLegacyLfm25VlWrongPrecisionCache(modelId);
+  if (await isTextModelReady(modelId, dtype)) {
+    if (payload?.requireTools === true) {
+      const runtime = await getDownloadedTextRuntime(modelId, dtype, device, { localFilesOnly: true });
+      assertToolCapableTextRuntime(runtime, modelId);
+    }
+    textDownloadState = {
+      ...textDownloadState,
+      status: 'ready',
+      ready: true,
+      modelId,
+      dtype,
+      progress: 100,
+      error: '',
+    };
+    postTextDownloadState({ force: true });
+    return textDownloadSnapshot();
+  }
+
+  const resuming = textDownloadState.status === 'paused'
+    && sameTextModel(textDownloadState.modelId, textDownloadState.dtype, modelId, dtype);
+  if (!resuming) textDownloadFiles.clear();
+  activeTextDownloadModelId = modelId;
+  textDownloadCancelMode = '';
+  const controller = new AbortController();
+  textDownloadAbortController = controller;
+  textDownloadState = {
+    status: 'downloading',
+    ready: false,
+    modelId,
+    dtype,
+    file: resuming ? textDownloadState.file : '',
+    loaded: resuming ? textDownloadState.loaded : 0,
+    total: resuming ? textDownloadState.total : 0,
+    progress: resuming ? textDownloadState.progress : 0,
+    error: '',
+  };
+  postTextDownloadState({ force: true });
+  onStarted?.(textDownloadSnapshot());
+
+  try {
+    const runtime = await getDownloadedTextRuntime(modelId, dtype, device);
+    if (payload?.requireTools === true) assertToolCapableTextRuntime(runtime, modelId);
+    if (textDownloadCancelMode) {
+      await disposeDownloadedTextRuntime(modelId);
+      return textDownloadSnapshot();
+    }
+    await markTextModelReady(modelId, dtype);
+    textDownloadState = {
+      ...textDownloadState,
+      status: 'ready',
+      ready: true,
+      progress: 100,
+      error: '',
+    };
+    postTextDownloadState({ force: true });
+    return textDownloadSnapshot();
+  } catch (error) {
+    if (textDownloadCancelMode === 'pause' || textDownloadCancelMode === 'stop' || controller.signal.aborted) {
+      textDownloadState = {
+        ...textDownloadState,
+        status: textDownloadCancelMode === 'stop' ? 'stopping' : 'paused',
+        ready: false,
+        error: '',
+      };
+      postTextDownloadState({ force: true });
+      return textDownloadSnapshot();
+    }
+    textDownloadState = {
+      ...textDownloadState,
+      status: 'error',
+      ready: false,
+      error: error?.message || String(error),
+    };
+    postTextDownloadState({ force: true });
+    throw error;
+  } finally {
+    if (textDownloadAbortController === controller) textDownloadAbortController = null;
+    activeTextDownloadModelId = '';
+  }
+}
+
+async function clearLegacyLfm25VlWrongPrecisionCache(modelId) {
+  if (modelId !== WEBGPU_LFM25_VL_16B_MODEL_ID || typeof caches === 'undefined') return 0;
+  const modelPath = `/${modelId}/`;
+  const wrongPrecisionFile = /\/onnx\/(?:decoder|embed_images)\.onnx(?:_data(?:_\d+)?)?(?:[?#]|$)/;
+  let deletedEntries = 0;
+  for (const name of await caches.keys()) {
+    if (!/transformers/i.test(name)) continue;
+    const cache = await caches.open(name);
+    for (const request of await cache.keys()) {
+      const url = safeDecodedUrl(request.url);
+      if (url.includes(modelPath) && wrongPrecisionFile.test(url) && await cache.delete(request)) {
+        deletedEntries++;
+      }
+    }
+  }
+  return deletedEntries;
+}
+
+function pauseTextDownload() {
+  if (textDownloadState.status !== 'downloading') return textDownloadSnapshot();
+  textDownloadCancelMode = 'pause';
+  textDownloadState = { ...textDownloadState, status: 'paused', ready: false, error: '' };
+  textDownloadAbortController?.abort();
+  postTextDownloadState({ force: true });
+  return textDownloadSnapshot();
+}
+
+async function clearTextModelCache(modelId, dtype) {
+  if (textRuntimeModelKey === textModelKey(modelId, dtype)) await disposeTextRuntime();
+  if (visionRuntimeOwner === 'text' && visionRuntimeModelKey === textModelKey(modelId, dtype)) {
+    await disposeVisionRuntime('text');
+  }
+  const modelPath = `/${modelId}/`;
+  const markerUrl = textReadyMarkerUrl(modelId, dtype);
+  if (typeof caches !== 'undefined') {
+    for (const name of await caches.keys()) {
+      if (!/transformers/i.test(name)) continue;
+      const cache = await caches.open(name);
+      for (const request of await cache.keys()) {
+        const url = safeDecodedUrl(request.url);
+        if (url.includes(modelPath) || request.url === markerUrl) await cache.delete(request);
+      }
+      await cache.delete(markerUrl);
+    }
+  }
+  readyTextModelKeys.delete(textModelKey(modelId, dtype));
+  textDownloadFiles.clear();
+  textDownloadCancelMode = '';
+  const clearedState = {
+    status: 'not-downloaded',
+    ready: false,
+    modelId,
+    dtype,
+    file: '',
+    loaded: 0,
+    total: 0,
+    progress: 0,
+    error: '',
+  };
+  const sameModel = !textDownloadState.modelId
+    || sameTextModel(textDownloadState.modelId, textDownloadState.dtype, modelId, dtype);
+  if (sameModel) {
+    textDownloadState = clearedState;
+    postTextDownloadState({ force: true });
+  }
+  return { ...clearedState };
+}
+
+function enqueueModelOperation(operation) {
+  const result = modelOperationQueue.then(operation, operation);
+  // Keep the queue usable after one request fails while preserving that
+  // failure for the caller awaiting `result`.
+  modelOperationQueue = result.catch(() => {});
+  return result;
+}
+
+function imageUrlFromBlock(block) {
+  if (block?.type === 'image_url') {
+    return typeof block.image_url === 'string'
+      ? block.image_url
+      : block.image_url?.url;
+  }
+  if (block?.type === 'image') {
+    return typeof block.image === 'string' ? block.image : block.url;
+  }
+  return '';
+}
+
+function prepareMultimodalMessages(messages) {
+  const imageUrls = [];
+  const prepared = [];
+  for (const message of Array.isArray(messages) ? messages : []) {
+    if (!message || typeof message !== 'object') continue;
+    const role = ['system', 'user', 'assistant', 'tool'].includes(message.role)
+      ? message.role
+      : 'user';
+    const imageBlocks = [];
+    const textBlocks = [];
+    if (Array.isArray(message.content)) {
+      for (const block of message.content) {
+        if (block?.type === 'text' && typeof block.text === 'string') {
+          textBlocks.push({ type: 'text', text: block.text });
+          continue;
+        }
+        const imageUrl = imageUrlFromBlock(block);
+        if (imageUrl) {
+          imageUrls.push(imageUrl);
+          imageBlocks.push({ type: 'image' });
+        }
+      }
+    } else if (typeof message.content === 'string') {
+      textBlocks.push({ type: 'text', text: message.content });
+    }
+    // LFM2.5-VL's published chat template places <image> before the question.
+    // Normalize OpenAI-style messages (which often put text first) to that
+    // model-specific contract without changing the provider-facing API.
+    const blocks = [...imageBlocks, ...textBlocks];
+    if (blocks.length || Array.isArray(message.tool_calls)) {
+      prepared.push({
+        role,
+        content: blocks,
+        ...(Array.isArray(message.tool_calls)
+          ? { tool_calls: message.tool_calls.map(normalizeTextToolCall) }
+          : {}),
+        ...(message.reasoning_content ? { reasoning_content: String(message.reasoning_content) } : {}),
+      });
+    }
+  }
+  return { messages: prepared, imageUrls };
+}
+
+function createVisionProbeImage(RawImage) {
+  if (!RawImage) throw new Error('The packaged runtime does not expose RawImage.');
+  // LFM2.5-VL-450M is much more dependable at coarse visual classification
+  // than fine OCR. Use three large, unlabeled color panels so the connection
+  // test still proves that pixels reached the model without asking it to read
+  // tiny synthetic glyphs.
+  const width = 480;
+  const height = 320;
+  const channels = 3;
+  const colors = [
+    [255, 255, 0],
+    [0, 0, 255],
+    [255, 0, 0],
+  ];
+  const data = new Uint8ClampedArray(width * height * channels);
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const targetOffset = (y * width + x) * channels;
+      const color = colors[Math.min(colors.length - 1, Math.floor(x / (width / colors.length)))];
+      for (let channel = 0; channel < channels; channel++) {
+        data[targetOffset + channel] = color[channel];
+      }
+    }
+  }
+  return new RawImage(data, width, height, channels);
+}
+
+async function runVision(payload, requestId) {
+  const modelId = String(payload?.modelId || '').trim();
+  if (!modelId) throw new Error('No vision model was specified.');
+  const device = payload?.device || 'webgpu';
+  const dtype = payload?.dtype || {
+    embed_tokens: 'fp16',
+    vision_encoder: 'fp16',
+    decoder_model_merged: 'q4',
+  };
+  const library = await loadLibrary();
+  const stoppingCriteria = library.InterruptableStoppingCriteria
+    ? new library.InterruptableStoppingCriteria()
+    : null;
+  if (stoppingCriteria) activeVisionGenerations.set(requestId, stoppingCriteria);
+  try {
+    if (cancelledVisionGenerations.has(requestId)) {
+      const error = new Error('Vision generation was cancelled.');
+      error.name = 'AbortError';
+      throw error;
+    }
+    const runtime = await getVisionRuntime(modelId, dtype, device, {
+      localFilesOnly: true,
+      owner: 'vision',
+      readiness: 'vision',
+    });
+    const { messages, imageUrls } = prepareMultimodalMessages(payload?.messages);
+    if (imageUrls.length !== 1) {
+      throw new Error(`LFM2.5-VL requires exactly one screenshot; received ${imageUrls.length}.`);
+    }
+    const prompt = runtime.processor.apply_chat_template(messages, {
+      add_generation_prompt: true,
+    });
+    const image = payload?.options?.visionProbe === true
+      ? createVisionProbeImage(runtime.library.RawImage)
+      : await runtime.library.load_image(imageUrls[0]);
+    const inputs = await runtime.processor(image, prompt, { add_special_tokens: false });
+    const requestedTokens = Number(payload?.options?.maxTokens);
+    const maxNewTokens = Number.isFinite(requestedTokens)
+      ? Math.max(1, Math.min(1600, Math.round(requestedTokens)))
+      : 800;
+    const outputs = await runtime.model.generate({
+      ...inputs,
+      do_sample: false,
+      max_new_tokens: maxNewTokens,
+      ...(stoppingCriteria ? { stopping_criteria: [stoppingCriteria] } : {}),
+    });
+    if (cancelledVisionGenerations.has(requestId)) {
+      const error = new Error('Vision generation was cancelled.');
+      error.name = 'AbortError';
+      throw error;
+    }
+    const inputLength = inputs.input_ids.dims.at(-1);
+    const generated = outputs.slice(null, [inputLength, null]);
+    const decoded = runtime.processor.batch_decode(generated, { skip_special_tokens: true });
+    return String(decoded?.[0] || '').trim();
+  } finally {
+    activeVisionGenerations.delete(requestId);
+    cancelledVisionGenerations.delete(requestId);
+  }
+}
+
+function normalizeTextToolCall(toolCall) {
+  if (!toolCall || typeof toolCall !== 'object') return toolCall;
+  const usesFunctionWrapper = toolCall.function && typeof toolCall.function === 'object';
+  const target = usesFunctionWrapper ? toolCall.function : toolCall;
+  let parsedArguments = target.arguments;
+  if (typeof parsedArguments === 'string') {
+    try {
+      parsedArguments = JSON.parse(parsedArguments);
+    } catch {
+      parsedArguments = {};
+    }
+  }
+  if (!parsedArguments || typeof parsedArguments !== 'object' || Array.isArray(parsedArguments)) {
+    // Ling's template calls .items() unconditionally, so malformed or omitted
+    // historical arguments must still be represented by an object.
+    parsedArguments = {};
+  }
+  if (parsedArguments === target.arguments) return toolCall;
+
+  if (usesFunctionWrapper) {
+    return {
+      ...toolCall,
+      function: { ...target, arguments: parsedArguments },
+    };
+  }
+  return { ...toolCall, arguments: parsedArguments };
+}
+
+export function prepareTextMessages(messages) {
+  return (Array.isArray(messages) ? messages : []).map(message => {
+    if (!message || typeof message !== 'object') return { role: 'user', content: '' };
+    const prepared = {
+      ...message,
+      ...(Array.isArray(message.tool_calls)
+        ? { tool_calls: message.tool_calls.map(normalizeTextToolCall) }
+        : {}),
+    };
+    if (Array.isArray(message.content)) {
+      const text = message.content
+        .filter(block => block?.type === 'text' && typeof block.text === 'string')
+        .map(block => block.text)
+        .join('\n');
+      return { ...prepared, content: text };
+    }
+    return { ...prepared, content: String(message.content || '') };
+  });
+}
+
+export function splitThinking(content, { openingTagInPrompt = false } = {}) {
+  const source = String(content || '').trim();
+  const match = /^<think>\s*([\s\S]*?)\s*<\/think>\s*([\s\S]*)$/i.exec(source);
+  if (match) {
+    return {
+      content: String(match[2] || '').trim(),
+      reasoningContent: String(match[1] || '').trim() || null,
+      incompleteReasoning: false,
+    };
+  }
+  if (!openingTagInPrompt) {
+    return { content: source, reasoningContent: null, incompleteReasoning: false };
+  }
+
+  // LFM2.5's official template places `<think>` in the generation prompt.
+  // Transformers.js therefore returns only the generated suffix: reasoning,
+  // `</think>`, then the user-facing answer.
+  const closingTag = /<\/think>/i.exec(source);
+  if (!closingTag) {
+    return {
+      content: '',
+      reasoningContent: source || null,
+      incompleteReasoning: !!source,
+    };
+  }
+  return {
+    content: source.slice(closingTag.index + closingTag[0].length).trim(),
+    reasoningContent: source.slice(0, closingTag.index).trim() || null,
+    incompleteReasoning: false,
+  };
+}
+
+function addLegacyVlTools(messages, tools) {
+  if (!tools.length) return messages;
+  const toolText = `List of tools: [${tools.map(tool => JSON.stringify(tool)).join(', ')}]`;
+  const prepared = messages.map(message => ({ ...message, content: [...(message.content || [])] }));
+  if (prepared[0]?.role === 'system') {
+    prepared[0].content.push({ type: 'text', text: `\n${toolText}` });
+  } else {
+    prepared.unshift({ role: 'system', content: [{ type: 'text', text: toolText }] });
+  }
+  return prepared;
+}
+
+async function runMultimodalText(payload) {
+  const modelId = assertOnnxTextModel(payload?.modelId);
+  if (!isLfm25VlModel(modelId)) {
+    throw new Error(`${modelId} is not a shipped WebGPU multimodal model.`);
+  }
+  const device = payload?.device || 'webgpu';
+  const dtype = payload?.dtype || {
+    embed_tokens: 'fp16',
+    vision_encoder: 'fp16',
+    decoder_model_merged: 'q4',
+  };
+  if (!await isTextModelReady(modelId, dtype)) {
+    throw new Error(`${modelId} is not downloaded. Open Apocalypse Mode > WebGPU to download it before chatting.`);
+  }
+  const runtime = await getVisionRuntime(modelId, dtype, device, {
+    localFilesOnly: true,
+    owner: 'text',
+    readiness: 'text',
+  });
+  const tools = Array.isArray(payload?.options?.tools) ? payload.options.tools : [];
+  let { messages, imageUrls } = prepareMultimodalMessages(payload?.messages);
+  if (modelId === WEBGPU_LFM25_VL_16B_MODEL_ID) messages = addLegacyVlTools(messages, tools);
+  const prompt = runtime.processor.apply_chat_template(messages, {
+    add_generation_prompt: true,
+    tools: tools.length ? tools : undefined,
+  });
+  let inputs;
+  if (imageUrls.length) {
+    const images = await Promise.all(imageUrls.map(url => runtime.library.load_image(url)));
+    inputs = await runtime.processor(images.length === 1 ? images[0] : images, prompt, {
+      add_special_tokens: false,
+    });
+  } else {
+    inputs = runtime.processor.tokenizer(prompt, { add_special_tokens: false });
+  }
+  const requestedTokens = Number(payload?.options?.maxTokens);
+  const maxNewTokens = Number.isFinite(requestedTokens)
+    ? Math.max(1, Math.min(1600, Math.round(requestedTokens)))
+    : 800;
+  lastWebGpuDeviceError = '';
+  lastWebGpuDeviceLost = '';
+  let outputs;
+  try {
+    outputs = await runtime.model.generate({
+      ...inputs,
+      do_sample: false,
+      max_new_tokens: maxNewTokens,
+    });
+  } catch (error) {
+    if (isWebGpuExecutionFailure(error)) throw await enrichWebGpuExecutionError(error);
+    throw error;
+  }
+  const inputLength = inputs.input_ids.dims.at(-1);
+  const generated = outputs.slice(null, [inputLength, null]);
+  const decoded = runtime.processor.batch_decode(generated, { skip_special_tokens: true });
+  const result = splitThinking(String(decoded?.[0] || '').trim());
+  return { content: result.content, reasoningContent: result.reasoningContent };
+}
+
+async function runText(payload) {
+  const modelId = assertOnnxTextModel(payload?.modelId);
+  const device = payload?.device || 'webgpu';
+  const dtype = payload?.dtype || 'q4f16';
+  const usesReasoningTemplate = WEBGPU_REASONING_MODEL_IDS.has(modelId);
+  const opensThinkingInPrompt = WEBGPU_OPEN_THINKING_MODEL_IDS.has(modelId);
+  const usesLongOutputBudget = WEBGPU_LONG_OUTPUT_MODEL_IDS.has(modelId);
+  const sampling = WEBGPU_TEXT_SAMPLING.get(modelId);
+  if (!await isTextModelReady(modelId, dtype)) {
+    throw new Error(`${modelId} is not downloaded. Open Apocalypse Mode > WebGPU to download it before chatting.`);
+  }
+  const runtime = await getTextRuntime(modelId, dtype, device, { localFilesOnly: true });
+  if (payload?.requireTools === true) assertToolCapableTextRuntime(runtime, modelId);
+  const requestedTokens = Number(payload?.options?.maxTokens);
+  const maxTokenLimit = usesLongOutputBudget
+    ? WEBGPU_LFM25_MAX_NEW_TOKENS
+    : WEBGPU_TEXT_MAX_NEW_TOKENS;
+  const maxNewTokens = Number.isFinite(requestedTokens)
+    ? Math.max(1, Math.min(maxTokenLimit, Math.round(requestedTokens)))
+    : maxTokenLimit;
+  const tools = Array.isArray(payload?.options?.tools) ? payload.options.tools : [];
+  lastWebGpuDeviceError = '';
+  lastWebGpuDeviceLost = '';
+  let output;
+  try {
+    output = await runtime.pipeline(prepareTextMessages(payload?.messages), {
+      do_sample: Boolean(sampling),
+      ...(sampling || {}),
+      max_new_tokens: maxNewTokens,
+      tools: tools.length ? tools : undefined,
+      // Reasoning templates re-open `<think>` for the pending turn and collapse
+      // completed thinking in history; the rest suppress thinking outright.
+      tokenizer_encode_kwargs: usesReasoningTemplate
+        ? { preserve_thinking: false }
+        : { enable_thinking: false },
+    });
+  } catch (error) {
+    if (isWebGpuExecutionFailure(error)) throw await enrichWebGpuExecutionError(error);
+    throw error;
+  }
+  const generated = output?.[0]?.generated_text;
+  const content = Array.isArray(generated)
+    ? generated.at(-1)?.content
+    : generated;
+  if (typeof content !== 'string') {
+    throw new Error('The WebGPU model returned no generated text.');
+  }
+  const result = splitThinking(content, { openingTagInPrompt: opensThinkingInPrompt });
+  if (result.incompleteReasoning) {
+    throw new Error(`${modelId} used its generation budget before finishing reasoning. Retry with a shorter prompt.`);
+  }
+  return { content: result.content, reasoningContent: result.reasoningContent };
+}
+
+async function probeRuntime() {
+  await loadLibrary();
+  const hasWebGPU = typeof navigator !== 'undefined' && !!navigator.gpu;
+  let adapter = null;
+  if (hasWebGPU) {
+    try { adapter = await navigator.gpu.requestAdapter({ powerPreference: 'high-performance' }); } catch {}
+  }
+  const isFallbackAdapter = !!(adapter?.isFallbackAdapter ?? adapter?.info?.isFallbackAdapter);
+  return {
+    libraryVersion,
+    hasWebGPU: hasWebGPU && !!adapter,
+    isFallbackAdapter,
+    adapterFeatures: adapter ? [...adapter.features].slice(0, 12) : [],
+  };
+}
+
+export async function clearVisionModelCache(modelId) {
+  const normalizedModelId = String(modelId || '').trim();
+  if (!normalizedModelId) throw new Error('No vision model was specified.');
+  await disposeVisionRuntime('vision');
+  const modelPath = `/${normalizedModelId}/`;
+  const markerUrl = visionReadyMarkerUrl(normalizedModelId);
+  let deletedEntries = 0;
+  if (typeof caches !== 'undefined') {
+    for (const name of await caches.keys()) {
+      if (!/transformers/i.test(name)) continue;
+      const cache = await caches.open(name);
+      for (const request of await cache.keys()) {
+        const url = safeDecodedUrl(request.url);
+        if (url.includes(modelPath) || isVisionReadyMarkerForModel(request.url, normalizedModelId)) {
+          if (await cache.delete(request)) deletedEntries++;
+        }
+      }
+      if (await cache.delete(markerUrl)) deletedEntries++;
+    }
+  }
+  return { modelId: normalizedModelId, deletedEntries };
+}
+
+self.addEventListener('message', async event => {
+  const { id, type, payload } = event.data || {};
+  try {
+    if (type === 'cancel') {
+      const requestId = Number(payload?.requestId);
+      const queued = queuedVisionGenerations.has(requestId);
+      const active = activeVisionGenerations.has(requestId);
+      const cancellable = Number.isFinite(requestId) && (queued || active);
+      if (cancellable) {
+        cancelledVisionGenerations.add(requestId);
+        activeVisionGenerations.get(requestId)?.interrupt?.();
+      }
+      self.postMessage({
+        id,
+        ok: true,
+        cancelled: cancellable,
+        requestId,
+        queued: queued && !active,
+        active,
+      });
+      return;
+    }
+    if (type === 'init') {
+      workerConfig = payload;
+      self.postMessage({ id, ok: true });
+      return;
+    }
+    if (type === 'probe') {
+      self.postMessage({ id, ok: true, ...(await probeRuntime()) });
+      return;
+    }
+    if (type === 'text-download-status') {
+      const modelId = String(payload?.modelId || '').trim();
+      const dtype = payload?.dtype || 'q4f16';
+      self.postMessage({ id, ok: true, ...(await getTextDownloadStatus(modelId, dtype)) });
+      return;
+    }
+    if (type === 'download-text') {
+      const state = await enqueueModelOperation(() => downloadTextModel(payload));
+      self.postMessage({ id, ok: true, ...state });
+      return;
+    }
+    if (type === 'start-download-text') {
+      const request = assertTextDownloadCanStart(payload);
+      queuedTextDownload = request;
+      let acknowledged = false;
+      const operation = enqueueModelOperation(() => {
+        if (queuedTextDownload !== request) return getTextDownloadStatus(request.modelId, request.dtype);
+        return downloadTextModel(payload, {
+          onStarted(state) {
+            acknowledged = true;
+            self.postMessage({ id, ok: true, ...state });
+          },
+        });
+      });
+      void operation.then((state) => {
+        if (!acknowledged) self.postMessage({ id, ok: true, ...state });
+      }).catch((error) => {
+        if (!acknowledged) self.postMessage({ id, ok: false, error: error?.message || String(error) });
+      }).finally(() => {
+        if (queuedTextDownload?.key === request.key) queuedTextDownload = null;
+      });
+      return;
+    }
+    if (type === 'pause-text-download') {
+      self.postMessage({ id, ok: true, ...pauseTextDownload() });
+      return;
+    }
+    if (type === 'stop-text-download') {
+      const modelId = String(payload?.modelId || '').trim();
+      const dtype = payload?.dtype || 'q4f16';
+      const targetsQueuedTransfer = queuedTextDownload
+        && sameTextModel(queuedTextDownload.modelId, queuedTextDownload.dtype, modelId, dtype);
+      if (targetsQueuedTransfer) queuedTextDownload = null;
+      const targetsTrackedTransfer = sameTextModel(textDownloadState.modelId, textDownloadState.dtype, modelId, dtype);
+      if (targetsTrackedTransfer) {
+        textDownloadCancelMode = 'stop';
+        textDownloadState = { ...textDownloadState, status: 'stopping', ready: false, error: '' };
+        if (activeTextDownloadModelId === modelId) textDownloadAbortController?.abort();
+        postTextDownloadState({ force: true });
+      }
+      const state = await enqueueModelOperation(() => clearTextModelCache(modelId, dtype));
+      self.postMessage({ id, ok: true, ...state });
+      return;
+    }
+    if (type === 'pause-vision-download') {
+      self.postMessage({ id, ok: true, ...pauseVisionDownload(payload?.modelId) });
+      return;
+    }
+    if (type === 'stop-vision-download') {
+      const modelId = String(payload?.modelId || '').trim();
+      if (!modelId) throw new Error('No vision model was specified.');
+      const stopped = stopVisionDownload(modelId);
+      // A queued preload owns no live vision operation. Clear its model-specific
+      // cache immediately so Stop is not trapped behind an unrelated text-model
+      // transfer in the shared WebGPU operation queue. The host may also pass
+      // targetsQueued after pause already dequeued that preload.
+      const targetsQueued = stopped.targetsQueued || payload?.targetsQueued === true;
+      const result = targetsQueued && !stopped.hasActiveVision
+        ? await clearVisionModelCache(modelId)
+        : await enqueueModelOperation(() => clearVisionModelCache(modelId));
+      self.postMessage({
+        id,
+        ok: true,
+        status: 'not-downloaded',
+        ready: false,
+        ...result,
+      });
+      return;
+    }
+    if (type === 'clear-cache') {
+      const modelId = String(payload?.modelId || '').trim();
+      const result = await enqueueModelOperation(() => clearVisionModelCache(modelId));
+      self.postMessage({ id, ok: true, ...result });
+      return;
+    }
+    if (type === 'dispose' || type === 'dispose-all') {
+      await enqueueModelOperation(disposeAllRuntimes);
+      self.postMessage({ id, ok: true, disposed: true });
+      return;
+    }
+    if (type === 'dispose-vision') {
+      await enqueueModelOperation(() => disposeVisionRuntime('vision'));
+      self.postMessage({ id, ok: true, disposed: true });
+      return;
+    }
+    if (type === 'dispose-text') {
+      await enqueueModelOperation(() => disposeDownloadedTextRuntime());
+      self.postMessage({ id, ok: true, disposed: true });
+      return;
+    }
+    if (type === 'preload') {
+      const modelId = String(payload?.modelId || '').trim();
+      if (!modelId) throw new Error('No vision model was specified.');
+      const request = {
+        modelId,
+        dtype: payload?.dtype || '',
+        cancelMode: '',
+      };
+      queuedVisionDownload = request;
+      self.postMessage({ type: 'vision-preload-state', modelId, status: 'queued' });
+      const state = await enqueueModelOperation(() => {
+        self.postMessage({ type: 'vision-preload-state', modelId, status: 'loading' });
+        return preloadVisionModel(payload, request);
+      });
+      if (queuedVisionDownload === request) queuedVisionDownload = null;
+      self.postMessage({ id, ok: true, ...state });
+      return;
+    }
+    if (type === 'chat') {
+      queuedVisionGenerations.add(id);
+      try {
+        const content = await enqueueModelOperation(() => runVision(payload, id));
+        self.postMessage({ id, ok: true, content, raw: { model: payload?.modelId || '' } });
+      } finally {
+        queuedVisionGenerations.delete(id);
+        cancelledVisionGenerations.delete(id);
+      }
+      return;
+    }
+    if (type === 'text-chat') {
+      const result = await enqueueModelOperation(() => runText(payload));
+      self.postMessage({
+        id,
+        ok: true,
+        ...result,
+        raw: { model: payload?.modelId || '' },
+      });
+      return;
+    }
+    if (type === 'multimodal-text-chat') {
+      const result = await enqueueModelOperation(() => runMultimodalText(payload));
+      self.postMessage({
+        id,
+        ok: true,
+        ...result,
+        raw: { model: payload?.modelId || '' },
+      });
+      return;
+    }
+    throw new Error(`Unknown WebGPU worker message: ${type || 'missing type'}`);
+  } catch (error) {
+    self.postMessage({ id, ok: false, error: error?.message || String(error) });
+  }
+});

runtime/tool-call-parser.js

@@ -0,0 +1,512 @@
+// Browser-free fallback parser for local models that emit tool calls as text
+// instead of using the provider's structured tool_calls field. This file is
+// mirrored in the Firefox tree; keep both copies byte-identical.
+
+// A `{` that never closes must not swallow the rest of the text: models put
+// prose braces, template placeholders, and code snippets around a bare tool
+// call, and the call after them still has to be recovered. Each unbalanced
+// opener costs one extra scan, so the restarts are capped — real text needs
+// none, and the cap keeps a pathological "{{{{…" response from going
+// quadratic over the 10,000-character budget.
+const MAX_UNBALANCED_RESTARTS = 16;
+
+/**
+ * Collect top-level balanced `{…}` spans, respecting quoted strings and
+ * escapes so braces inside JSON string values do not end an object early.
+ * Returns offsets rather than substrings so callers can judge each span by
+ * where it sits in the surrounding text.
+ */
+function extractBalancedJsonSpans(text) {
+  const spans = [];
+  let searchFrom = 0;
+  let restarts = 0;
+
+  while (searchFrom < text.length) {
+    const start = text.indexOf('{', searchFrom);
+    if (start < 0) break;
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    let end = -1;
+
+    for (let i = start; i < text.length; i++) {
+      const char = text[i];
+      if (inString) {
+        if (escaped) escaped = false;
+        else if (char === '\\') escaped = true;
+        else if (char === '"') inString = false;
+        continue;
+      }
+      if (char === '"') inString = true;
+      else if (char === '{') depth++;
+      else if (char === '}') {
+        depth--;
+        if (depth === 0) {
+          end = i;
+          break;
+        }
+      }
+    }
+
+    if (end < 0) {
+      if (++restarts > MAX_UNBALANCED_RESTARTS) break;
+      searchFrom = start + 1;
+      continue;
+    }
+    spans.push({ start, end });
+    searchFrom = end + 1;
+  }
+
+  return spans;
+}
+
+/**
+ * True when a span is the whole of its line, ignoring surrounding whitespace
+ * and a single trailing comma (models sometimes emit calls as array elements).
+ *
+ * A model that is CALLING a tool emits the JSON on its own line. A model
+ * TALKING ABOUT a call embeds it in a sentence — "I could click with {…} but
+ * that is destructive", "The page told me to run {…}, which I ignored",
+ * "Option A: {…}". Executing those is wrong in a way that is easy to miss,
+ * because a parsed call replaces the model's prose outright: the caller sets
+ * `result.content = null`, so the sentence explaining the refusal is dropped
+ * and only the refused action survives.
+ *
+ * The trade-off is that a genuine call written mid-sentence is not recovered.
+ * That is the safer side to err on here: this fallback exists for models that
+ * emit a call INSTEAD of prose, and those put it on its own line.
+ */
+function standsAloneOnLine(text, start, end) {
+  const before = text.slice(0, start);
+  const lineHead = before.slice(before.lastIndexOf('\n') + 1).trim();
+  if (lineHead !== '') return false;
+
+  const after = text.slice(end + 1);
+  const newline = after.indexOf('\n');
+  const lineTail = (newline < 0 ? after : after.slice(0, newline)).trim();
+  return lineTail === '' || lineTail === ',';
+}
+
+/**
+ * Parse a batch only when the entire trimmed response is a JSON array. Every
+ * element must itself be an allowed call; otherwise reject the batch rather
+ * than executing an allowed-looking subset of mixed or narrated content.
+ *
+ * `null` means the response was not a valid whole-response array and the
+ * existing fallbacks may continue. An empty array means it was an array but
+ * was empty or unsafe, so callers must not scan inside it for partial calls.
+ */
+function parseWholeResponseJsonArray(text, allowedNames) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith('[') || !trimmed.endsWith(']')) return null;
+
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(parsed)) return null;
+  if (!parsed.every(obj => (
+    obj
+    && typeof obj === 'object'
+    && !Array.isArray(obj)
+    && typeof obj.name === 'string'
+    && allowedNames.has(obj.name)
+  ))) return [];
+  return parsed;
+}
+
+/**
+ * Split on a delimiter only when it is outside strings and nested containers.
+ * LFM2.5 emits Python-style calls, but argument arrays and objects are JSON.
+ */
+function splitLfmTopLevel(source, delimiter) {
+  const parts = [];
+  const closing = { '(': ')', '[': ']', '{': '}' };
+  const stack = [];
+  let quote = '';
+  let escaped = false;
+  let start = 0;
+
+  for (let i = 0; i < source.length; i++) {
+    const char = source[i];
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = '';
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (closing[char]) {
+      stack.push(closing[char]);
+      continue;
+    }
+    if (char === ')' || char === ']' || char === '}') {
+      if (stack.pop() !== char) return null;
+      continue;
+    }
+    if (char === delimiter && stack.length === 0) {
+      parts.push(source.slice(start, i));
+      start = i + 1;
+    }
+  }
+
+  if (quote || escaped || stack.length > 0) return null;
+  parts.push(source.slice(start));
+  return parts;
+}
+
+function parseLfmString(source) {
+  const quote = source[0];
+  if ((quote !== '"' && quote !== "'") || source.at(-1) !== quote) return null;
+  let output = '';
+  const escapes = {
+    '\\': '\\',
+    '"': '"',
+    "'": "'",
+    n: '\n',
+    r: '\r',
+    t: '\t',
+    b: '\b',
+    f: '\f',
+  };
+
+  for (let i = 1; i < source.length - 1; i++) {
+    const char = source[i];
+    if (char === quote) return null;
+    if (char !== '\\') {
+      if (char === '\n' || char === '\r') return null;
+      output += char;
+      continue;
+    }
+    if (++i >= source.length - 1) return null;
+    const escaped = source[i];
+    if (Object.hasOwn(escapes, escaped)) {
+      output += escapes[escaped];
+      continue;
+    }
+    const width = escaped === 'u' ? 4 : escaped === 'x' ? 2 : 0;
+    const hex = width ? source.slice(i + 1, i + 1 + width) : '';
+    if (!width || !new RegExp(`^[0-9a-fA-F]{${width}}$`).test(hex)) return null;
+    output += String.fromCodePoint(Number.parseInt(hex, 16));
+    i += width;
+  }
+  return output;
+}
+
+function parseLfmValue(source) {
+  const value = source.trim();
+  if (!value) return { ok: false };
+  if (value[0] === '"' || value[0] === "'") {
+    const parsed = parseLfmString(value);
+    return parsed === null ? { ok: false } : { ok: true, value: parsed };
+  }
+  if (value[0] === '[' || value[0] === '{') {
+    try {
+      return { ok: true, value: JSON.parse(value) };
+    } catch {
+      return { ok: false };
+    }
+  }
+  if (value === 'True' || value === 'true') return { ok: true, value: true };
+  if (value === 'False' || value === 'false') return { ok: true, value: false };
+  if (value === 'None' || value === 'null') return { ok: true, value: null };
+  if (/^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:e[+-]?\d+)?$/i.test(value)) {
+    const number = Number(value);
+    return Number.isFinite(number) ? { ok: true, value: number } : { ok: false };
+  }
+  return { ok: false };
+}
+
+const LFM_DIRECTIONAL_SCROLL_ALIASES = Object.freeze({
+  scrollup: 'up',
+  scrolldown: 'down',
+  scrolltop: 'top',
+  scrollbottom: 'bottom',
+});
+
+/**
+ * Parse LFM2/LFM2.5's documented native format:
+ * <|tool_call_start|>[tool_name(key='value', flag=False)]<|tool_call_end|>
+ *
+ * The wrapper must occupy the whole response, and every call must be valid and
+ * allowlisted. A recognized but unsafe block returns an empty atomic batch so
+ * later generic scanners cannot execute JSON fragments embedded inside it.
+ */
+function parseLfmToolCalls(text, allowedNames) {
+  const startToken = '<|tool_call_start|>';
+  const endToken = '<|tool_call_end|>';
+  const source = text.trim();
+  if (!source.includes(startToken) && !source.includes(endToken)) return null;
+  if (!source.startsWith(startToken) || !source.endsWith(endToken)) return [];
+  const inner = source.slice(startToken.length, -endToken.length).trim();
+  if (inner.includes(startToken) || inner.includes(endToken)) return [];
+  if (!inner.startsWith('[') || !inner.endsWith(']')) return [];
+
+  const callParts = splitLfmTopLevel(inner.slice(1, -1), ',');
+  if (!callParts || callParts.length === 0 || callParts.some(part => !part.trim())) return [];
+  const calls = [];
+  for (const part of callParts) {
+    const match = /^([A-Za-z_]\w*)\s*\(([\s\S]*)\)$/.exec(part.trim());
+    if (!match) return [];
+    const aliasDirection = LFM_DIRECTIONAL_SCROLL_ALIASES[match[1]] || '';
+    const toolName = aliasDirection ? 'scroll' : match[1];
+    if (!allowedNames.has(toolName)) return [];
+    const args = Object.create(null);
+    if (match[2].trim()) {
+      const argParts = splitLfmTopLevel(match[2], ',');
+      if (!argParts || argParts.some(arg => !arg.trim())) return [];
+      for (const arg of argParts) {
+        const assignment = splitLfmTopLevel(arg, '=');
+        if (!assignment || assignment.length !== 2) return [];
+        const key = assignment[0].trim();
+        if (!/^[A-Za-z_]\w*$/.test(key) || Object.hasOwn(args, key)) return [];
+        const parsed = parseLfmValue(assignment[1]);
+        if (!parsed.ok) return [];
+        args[key] = parsed.value;
+      }
+    }
+    if (aliasDirection) {
+      if (Object.hasOwn(args, 'direction') && args.direction !== aliasDirection) return [];
+      args.direction = aliasDirection;
+    }
+    calls.push({ name: toolName, arguments: args });
+  }
+  return calls;
+}
+
+/**
+ * Quote relaxed `key:` tokens only when they occur outside JSON strings and
+ * after an object boundary. A regular-expression replacement corrupts string
+ * values such as "Keep, status: pending" before JSON.parse sees them.
+ */
+function quoteBareJsonKeys(body) {
+  const source = String(body || '');
+  let output = '';
+  let inString = false;
+  let escaped = false;
+
+  for (let i = 0; i < source.length;) {
+    const char = source[i];
+    if (inString) {
+      output += char;
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === '"') inString = false;
+      i++;
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      output += char;
+      i++;
+      continue;
+    }
+    if (/\w/.test(char)) {
+      let previous = i - 1;
+      while (previous >= 0 && /\s/.test(source[previous])) previous--;
+      if (previous < 0 || source[previous] === '{' || source[previous] === ',') {
+        let keyEnd = i + 1;
+        while (keyEnd < source.length && /\w/.test(source[keyEnd])) keyEnd++;
+        let colon = keyEnd;
+        while (colon < source.length && /\s/.test(source[colon])) colon++;
+        if (source[colon] === ':') {
+          output += `"${source.slice(i, keyEnd)}"${source.slice(keyEnd, colon + 1)}`;
+          i = colon + 1;
+          continue;
+        }
+      }
+    }
+    output += char;
+    i++;
+  }
+  return output;
+}
+
+function toFallbackToolCalls(objects) {
+  return objects.map((obj, index) => ({
+    id: `fallback_call_${Date.now()}_${index}`,
+    type: 'function',
+    function: {
+      name: obj.name,
+      arguments: typeof obj.arguments === 'string'
+        ? obj.arguments
+        : JSON.stringify(obj.arguments || obj.parameters || {}),
+    },
+  }));
+}
+
+/**
+ * Parse common text tool-call formats into OpenAI-style tool call objects.
+ * Only names in allowedNames are accepted.
+ */
+export function parseToolCallsFromText(text, allowedNames) {
+  if (!text || text.length > 10000) return [];
+
+  const lfmCalls = parseLfmToolCalls(text, allowedNames);
+  if (lfmCalls !== null) return toFallbackToolCalls(lfmCalls);
+
+  const wholeResponseArray = parseWholeResponseJsonArray(text, allowedNames);
+  if (wholeResponseArray !== null) {
+    return toFallbackToolCalls(wholeResponseArray);
+  }
+
+  const results = [];
+  const parseXmlParamValue = (value) => {
+    const raw = String(value || '');
+    // MiniCPM5 wraps values containing <, &, or newlines in CDATA. Extract
+    // the literal content first so the tag strip below does not eat it.
+    const cdataMatch = /^\s*<!\[CDATA\[([\s\S]*?)\]\]>\s*$/.exec(raw);
+    if (cdataMatch) return cdataMatch[1];
+    const cleaned = raw
+      .replace(/<[^>]+>/g, '')
+      .trim();
+    if (!cleaned) return '';
+    try {
+      if (/^(?:"|'.*'|\{|\[|-?\d|true\b|false\b|null\b)/i.test(cleaned)) {
+        return JSON.parse(cleaned.replace(/^'([\s\S]*)'$/, '"$1"'));
+      }
+    } catch { /* fall through to string cleanup */ }
+    return cleaned.replace(/^["']+|["']+$/g, '');
+  };
+  const parseBailingToolCall = (inner) => {
+    const nameMatch = /^([A-Za-z_]\w*)/.exec(inner);
+    if (!nameMatch || !allowedNames.has(nameMatch[1])) return null;
+    let cursor = nameMatch[0].length;
+    const args = {};
+    const pairRe = /<arg_key>\s*([A-Za-z_]\w*)\s*<\/arg_key>\s*<arg_value>\s*([\s\S]*?)\s*<\/arg_value>/giy;
+    while (cursor < inner.length) {
+      while (cursor < inner.length && /\s/.test(inner[cursor])) cursor++;
+      if (cursor >= inner.length) break;
+      pairRe.lastIndex = cursor;
+      const pair = pairRe.exec(inner);
+      if (!pair || pair.index !== cursor) return null;
+      args[pair[1]] = parseXmlParamValue(pair[2]);
+      cursor = pairRe.lastIndex;
+    }
+    return { name: nameMatch[1], arguments: args };
+  };
+
+  const patterns = [
+    /<tool_call>\s*([\s\S]*?)\s*<\/tool_call>/gi,
+    /<\|tool_call\|?>\s*([\s\S]*?)\s*<\|?\/?tool_call\|?>/gi,
+    /<functioncall>\s*([\s\S]*?)\s*<\/functioncall>/gi,
+  ];
+
+  for (const re of patterns) {
+    let match;
+    while ((match = re.exec(text)) !== null) {
+      const inner = match[1].trim();
+      const wrappedArray = parseWholeResponseJsonArray(inner, allowedNames);
+      if (wrappedArray !== null) {
+        results.push(...wrappedArray);
+        continue;
+      }
+      try {
+        const obj = JSON.parse(inner);
+        if (obj && obj.name && allowedNames.has(obj.name)) {
+          results.push(obj);
+          continue;
+        }
+      } catch { /* not JSON — try call:name{} format below */ }
+
+      // Ling/Bailing V3 native tool format:
+      // <tool_call>click_ax\n<arg_key>ref_id</arg_key>\n<arg_value>ref_7</arg_value></tool_call>
+      const bailingCall = parseBailingToolCall(inner);
+      if (bailingCall) {
+        results.push(bailingCall);
+        continue;
+      }
+
+      const callMatch = /^call:(\w+)\s*\{([\s\S]*)\}$/.exec(inner);
+      if (callMatch && allowedNames.has(callMatch[1])) {
+        const toolName = callMatch[1];
+        let argsBody = callMatch[2]
+          .replace(/<\|"\|>/g, '"')
+          .replace(/<\|'\\?\|>/g, "'");
+        argsBody = quoteBareJsonKeys(argsBody);
+        try {
+          const args = JSON.parse(`{${argsBody}}`);
+          results.push({ name: toolName, arguments: args });
+        } catch { /* malformed arguments must never dispatch */ }
+      }
+    }
+  }
+
+  // XML-ish tool-call format used by some local/chat-template models:
+  // <tool_call><function=click_ax><parameter=ref_id>ref_6</parameter>...
+  const xmlToolRe = /<tool_call>\s*<function(?:\s*=\s*["']?([A-Za-z_]\w*)["']?|\s+name\s*=\s*["']?([A-Za-z_]\w*)["']?)\s*>\s*([\s\S]*?)\s*<\/function>\s*<\/tool_call>/gi;
+  const xmlToolSpans = [];
+  let xmlMatch;
+  while ((xmlMatch = xmlToolRe.exec(text)) !== null) {
+    xmlToolSpans.push({ start: xmlMatch.index, end: xmlMatch.index + xmlMatch[0].length });
+    const toolName = xmlMatch[1] || xmlMatch[2];
+    if (!allowedNames.has(toolName)) continue;
+    const body = xmlMatch[3] || '';
+    const args = {};
+    const paramRe = /<(?:param|parameter)(?:\s*=\s*["']?([A-Za-z_]\w*)["']?|\s+name\s*=\s*["']?([A-Za-z_]\w*)["']?)\s*>\s*([\s\S]*?)\s*<\/(?:param|parameter)>/gi;
+    let paramMatch;
+    while ((paramMatch = paramRe.exec(body)) !== null) {
+      const key = paramMatch[1] || paramMatch[2];
+      if (!key) continue;
+      args[key] = parseXmlParamValue(paramMatch[3]);
+    }
+    results.push({ name: toolName, arguments: args });
+  }
+
+  // MiniCPM5-2B native tool format (no outer <tool_call> wrapper):
+  // <function name="click"><param name="ref_id">ref_6</param>...</function>
+  const minicpmFunctionRe = /<function(?:\s+name\s*=\s*["']([A-Za-z_]\w*)["']|\s*=\s*["']?([A-Za-z_]\w*)["']?)\s*>\s*([\s\S]*?)\s*<\/function>/gi;
+  let minicpmMatch;
+  while ((minicpmMatch = minicpmFunctionRe.exec(text)) !== null) {
+    // Skip functions already consumed inside a <tool_call> wrapper above.
+    if (xmlToolSpans.some(span => minicpmMatch.index >= span.start && minicpmMatch.index < span.end)) continue;
+    const toolName = minicpmMatch[1] || minicpmMatch[2];
+    if (!allowedNames.has(toolName)) continue;
+    const body = minicpmMatch[3] || '';
+    const args = {};
+    const paramRe = /<(?:param|parameter)(?:\s*=\s*["']?([A-Za-z_]\w*)["']?|\s+name\s*=\s*["']?([A-Za-z_]\w*)["']?)\s*>\s*([\s\S]*?)\s*<\/(?:param|parameter)>/gi;
+    let paramMatch;
+    while ((paramMatch = paramRe.exec(body)) !== null) {
+      const key = paramMatch[1] || paramMatch[2];
+      if (!key) continue;
+      args[key] = parseXmlParamValue(paramMatch[3]);
+    }
+    results.push({ name: toolName, arguments: args });
+  }
+
+  if (results.length === 0) {
+    for (const { start, end } of extractBalancedJsonSpans(text)) {
+      if (!standsAloneOnLine(text, start, end)) continue;
+      try {
+        const obj = JSON.parse(text.slice(start, end + 1));
+        if (obj && obj.name && allowedNames.has(obj.name)) {
+          results.push(obj);
+        }
+      } catch { /* skip */ }
+    }
+  }
+
+  if (results.length === 0) {
+    const callRe = /call:(\w+)\s*\{([\s\S]*?)\}/g;
+    let match;
+    while ((match = callRe.exec(text)) !== null) {
+      if (!allowedNames.has(match[1])) continue;
+      const toolName = match[1];
+      let argsBody = match[2]
+        .replace(/<\|"\|>/g, '"')
+        .replace(/<\|'\\?\|>/g, "'");
+      argsBody = quoteBareJsonKeys(argsBody);
+      try {
+        const args = JSON.parse(`{${argsBody}}`);
+        results.push({ name: toolName, arguments: args });
+      } catch { /* malformed arguments must never dispatch */ }
+    }
+  }
+
+  return toFallbackToolCalls(results);
+}

runtime/vendor/LICENSE.onnxruntime.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Microsoft Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

runtime/vendor/LICENSE.transformers.txt

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

runtime/vendor/README.md

@@ -0,0 +1,162 @@
+# Vendored Transformers.js WebGPU runtime
+
+This directory packages the JavaScript and WASM runtime used by two local
+WebGPU paths in Chrome and by offline RAG's CPU/WASM semantic reranker:
+
+- **Apocalypse Mode -> local WebGPU chat** downloads the selected LFM2.5 text
+  or vision-language preset, or the Nanbeige4.2-3B ONNX export, used by the
+  standalone-chat nuclear override. An opt-in Bonsai 27B preset uses a separate
+  vendored bitgpu worker, not this Transformers.js runtime; see
+  `src/chrome/vendor/bitgpu/README.webbrain.md`.
+- **Settings -> Multimodal -> Vision -> LFM2.5-VL local fallback** runs
+  `LiquidAI/LFM2.5-VL-450M-ONNX` as the dedicated screenshot sidecar.
+- **Apocalypse Mode -> Offline RAG** runs the explicitly downloaded, pinned
+  `Xenova/multilingual-e5-small` q8 model in a separate CPU/WASM worker. Model
+  weights remain optional and are never bundled or downloaded by a question.
+
+Model weights are not bundled. Transformers.js downloads each selected WebGPU
+model on first use and stores it in the browser cache. The shipped ONNX chat
+presets are LFM2.5 2.6B, 1.2B Instruct, 1.2B Thinking, VL 1.6B, VL 3B, and
+Nanbeige4.2-3B.
+They are available through the nuclear control in standalone chat and can also
+be selected as the normal provider after download. The reasoning presets keep
+completed thinking out of visible answers. Current LFM2.5-VL layouts use:
+
+- `embed_tokens`: FP16
+- `vision_encoder`: FP16
+- `decoder_model_merged`: Q4
+
+`Michionlion/Nanbeige4.2-3B-ONNX-WebGPU` needs no bundle patch, but it does
+need two things from this runtime. It publishes one WebGPU-fused graph named
+`onnx/model_webgpu_mlp_q4f16.onnx` instead of the default `model_q4f16.onnx`,
+so the worker passes `model_file_name: 'model_webgpu_mlp'`; the two external
+data shards are declared by the repository's own
+`transformers.js_config.use_external_data_format`. Its graph also uses the
+`com.microsoft::MatMulNBitsMlp` WebGPU kernel, which is compiled into the
+vendored `ort-wasm-simd-threaded.asyncify.wasm`. Do not replace the ONNX
+Runtime artifacts with a build that drops that kernel; a test asserts it is
+present because its absence only shows up as an opaque session-creation
+failure at runtime.
+
+The dedicated 450M vision sidecar uses the same component layout and is
+approximately 810 MB. The VL 1.6B chat export instead names its vision and
+decoder components `embed_images` and `decoder`; the compatibility patch below
+maps those files into the standard image-text session names.
+
+## Packaged files
+
+| File / directory | Source | Purpose |
+| --- | --- | --- |
+| `transformers.web.js` | `@huggingface/transformers` 4.2.0 | Browser ESM model/processor APIs |
+| `ort.webgpu.mjs` | `onnxruntime-web` 1.27.0 | WebGPU execution provider |
+| `onnxruntime-common/` | matching `onnxruntime-common` dependency | Tensor and session types |
+| `ort-wasm-simd-threaded.asyncify.*` | `onnxruntime-web` 1.27.0 | The only WASM bridge; carries the WebGPU/JSEP runtime |
+| `LICENSE.transformers.txt` | `@huggingface/transformers` 4.2.0 | Apache-2.0 license |
+| `LICENSE.onnxruntime.txt` | ONNX Runtime 1.27.0 | MIT license |
+| `ThirdPartyNotices.onnxruntime.txt` | ONNX Runtime 1.27.0 | Notices for incorporated third-party software |
+
+The readable, unminified browser builds are committed so a fresh checkout is a
+complete, Chrome Web Store-reviewable extension. Remote executable code is not
+allowed by Manifest V3 CSP; only model/config/tokenizer data is fetched from
+Hugging Face.
+
+Only the asyncify variant is vendored. `ort.webgpu.mjs` resolves its WASM
+filename from flags fixed at ONNX Runtime build time, and in this build the jsep
+and jspi branches are compiled out, so `ort-wasm-simd-threaded.asyncify.*` is the
+only bridge that can ever load. The WebGPU/JSEP execution provider lives inside
+that artifact; it is not a separate download. Copying the `jsep` or `jspi` pair
+adds tens of megabytes of unreachable binary to the reviewed package, so do not
+restore them without first checking that filename branch.
+
+The ONNX Runtime files are intentionally newer than the version pinned by
+Transformers.js 4.2.0. Stable 1.27.0 contains WebGPU buffer-pool and
+Qwen3/QMoE correctness fixes needed by Ling while retaining the same public
+JavaScript session API used by this Transformers.js release.
+
+## Browser bundle patches
+
+The upstream browser bundle contains two bare module specifiers that an
+unbundled extension cannot resolve. After copying a new release, rewrite them:
+
+```bash
+sed -i 's|"onnxruntime-web/webgpu"|"./ort.webgpu.mjs"|' \
+  src/chrome/vendor/transformers/transformers.web.js
+sed -i 's|"onnxruntime-common"|"./onnxruntime-common/index.js"|' \
+  src/chrome/vendor/transformers/transformers.web.js
+```
+
+Verify that no executable bare imports remain:
+
+```bash
+grep -E '(import|export)[^"]*from\s+"[a-zA-Z@]' \
+  src/chrome/vendor/transformers/transformers.web.js \
+  | grep -v '^\s*//' | grep -v '^\s*\*'
+```
+
+The LFM2.5-VL ONNX repositories need two compatibility hooks. The 1.6B export
+predates the standard ImageTextToText component filenames, so keep the small
+`session_file_names` alias hook in
+`MODEL_SESSION_CONFIG[MODEL_TYPES.ImageTextToText]`; the worker supplies aliases
+through `config["transformers.js_config"]`. Keep the corresponding `getSession`
+logic resolving device and dtype by logical `session_name`, while using the
+aliased filename only to fetch the physical ONNX graph. Both current VL exports
+also use the Transformers v5 processor layout: image metadata is nested in
+`processor_config.json`, and the chat template lives in `chat_template.jinja`.
+Keep `loadImageProcessorConfig`, `image_processor_config_file`, and
+`chat_template_file` support so the worker can opt into that layout without
+changing older models. Reapply these patches after replacing
+`transformers.web.js`, and mirror the resulting browser bundle into Firefox so
+the packaged vendor files remain byte-identical.
+
+## Updating
+
+Use a temporary dependency install; WebBrain does not need a runtime npm
+dependency because the reviewed browser assets are committed directly:
+
+```bash
+npm install --no-save @huggingface/transformers@latest
+cp node_modules/@huggingface/transformers/dist/transformers.web.js \
+  src/chrome/vendor/transformers/
+cp node_modules/onnxruntime-web/dist/ort.webgpu.mjs \
+  src/chrome/vendor/transformers/
+cp node_modules/onnxruntime-web/dist/ort-wasm-simd-threaded.asyncify.{mjs,wasm} \
+  src/chrome/vendor/transformers/
+rm -rf src/chrome/vendor/transformers/onnxruntime-common
+mkdir src/chrome/vendor/transformers/onnxruntime-common
+cp node_modules/onnxruntime-common/dist/esm/*.js \
+  src/chrome/vendor/transformers/onnxruntime-common/
+```
+
+Copy the Transformers.js license and the ONNX Runtime license plus
+`ThirdPartyNotices.txt` into this directory whenever the runtime is updated.
+Reapply the specifier and ImageTextToText session-alias patches, update the
+version table above, then verify:
+
+1. `node --check` passes for the provider, host, and worker.
+2. **Use local fallback** enables the option without downloading weights.
+3. **Test Connection** reads `WB7` from the packaged vision probe image.
+4. The second test reuses browser-cached model files.
+
+## Runtime architecture
+
+```text
+ProviderManager._createProvider('webgpu') / getVisionProvider()
+  -> WebGPUProvider.chat() / WebGPUVisionProvider.chat()
+  -> MV3 offscreen document
+  -> dedicated module Worker
+  -> text-generation pipeline / AutoProcessor + AutoModelForImageTextToText
+  -> selected LFM2.5 or Nanbeige ONNX repo / LFM2.5-VL-450M-ONNX over WebGPU
+```
+
+Keep inference in the Worker. The MV3 service worker has no WebGPU, while the
+offscreen document's main thread has shown tighter WASM allocation limits for
+large ONNX runs. Do not set `preferredOutputLocation: 'gpu-buffer'` on this
+generation path: Transformers.js decodes the generated tensor on the CPU and
+must be allowed to download that output normally.
+
+LFM2.5-VL expects the image placeholder before the user's text in its chat
+template. The Worker normalizes incoming OpenAI-style multimodal messages to
+that order. For the connection test, it replaces the packaged generic OCR image
+with three large, unlabeled color panels. This proves the local model received
+pixels without relying on fine OCR, which is brittle for a 450M model. Normal
+screenshots are never replaced by this probe-only path.

runtime/vendor/onnxruntime-common/backend-impl.js

@@ -0,0 +1,142 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+const backends = new Map();
+const backendsSortedByPriority = [];
+/**
+ * Register a backend.
+ *
+ * @param name - the name as a key to lookup as an execution provider.
+ * @param backend - the backend object.
+ * @param priority - an integer indicating the priority of the backend. Higher number means higher priority. if priority
+ * < 0, it will be considered as a 'beta' version and will not be used as a fallback backend by default.
+ *
+ * @ignore
+ */
+export const registerBackend = (name, backend, priority) => {
+    if (backend && typeof backend.init === 'function' && typeof backend.createInferenceSessionHandler === 'function') {
+        const currentBackend = backends.get(name);
+        if (currentBackend === undefined) {
+            backends.set(name, { backend, priority });
+        }
+        else if (currentBackend.priority > priority) {
+            // same name is already registered with a higher priority. skip registeration.
+            return;
+        }
+        else if (currentBackend.priority === priority) {
+            if (currentBackend.backend !== backend) {
+                throw new Error(`cannot register backend "${name}" using priority ${priority}`);
+            }
+        }
+        if (priority >= 0) {
+            const i = backendsSortedByPriority.indexOf(name);
+            if (i !== -1) {
+                backendsSortedByPriority.splice(i, 1);
+            }
+            for (let i = 0; i < backendsSortedByPriority.length; i++) {
+                if (backends.get(backendsSortedByPriority[i]).priority <= priority) {
+                    backendsSortedByPriority.splice(i, 0, name);
+                    return;
+                }
+            }
+            backendsSortedByPriority.push(name);
+        }
+        return;
+    }
+    throw new TypeError('not a valid backend');
+};
+/**
+ * Try to resolve and initialize a backend.
+ *
+ * @param backendName - the name of the backend.
+ * @returns the backend instance if resolved and initialized successfully, or an error message if failed.
+ */
+const tryResolveAndInitializeBackend = async (backendName) => {
+    const backendInfo = backends.get(backendName);
+    if (!backendInfo) {
+        return 'backend not found.';
+    }
+    if (backendInfo.initialized) {
+        return backendInfo.backend;
+    }
+    else if (backendInfo.aborted) {
+        return backendInfo.error;
+    }
+    else {
+        const isInitializing = !!backendInfo.initPromise;
+        try {
+            if (!isInitializing) {
+                backendInfo.initPromise = backendInfo.backend.init(backendName);
+            }
+            await backendInfo.initPromise;
+            backendInfo.initialized = true;
+            return backendInfo.backend;
+        }
+        catch (e) {
+            if (!isInitializing) {
+                backendInfo.error = `${e}`;
+                backendInfo.aborted = true;
+            }
+            return backendInfo.error;
+        }
+        finally {
+            delete backendInfo.initPromise;
+        }
+    }
+};
+/**
+ * Resolve execution providers from the specific session options.
+ *
+ * @param options - the session options object.
+ * @returns a promise that resolves to a tuple of an initialized backend instance and a session options object with
+ * filtered EP list.
+ *
+ * @ignore
+ */
+export const resolveBackendAndExecutionProviders = async (options) => {
+    // extract backend hints from session options
+    const eps = options.executionProviders || [];
+    const backendHints = eps.map((i) => (typeof i === 'string' ? i : i.name));
+    const backendNames = backendHints.length === 0 ? backendsSortedByPriority : backendHints;
+    // try to resolve and initialize all requested backends
+    let backend;
+    const errors = [];
+    const availableBackendNames = new Set();
+    for (const backendName of backendNames) {
+        const resolveResult = await tryResolveAndInitializeBackend(backendName);
+        if (typeof resolveResult === 'string') {
+            errors.push({ name: backendName, err: resolveResult });
+        }
+        else {
+            if (!backend) {
+                backend = resolveResult;
+            }
+            if (backend === resolveResult) {
+                availableBackendNames.add(backendName);
+            }
+        }
+    }
+    // if no backend is available, throw error.
+    if (!backend) {
+        throw new Error(`no available backend found. ERR: ${errors.map((e) => `[${e.name}] ${e.err}`).join(', ')}`);
+    }
+    // for each explicitly requested backend, if it's not available, output warning message.
+    for (const { name, err } of errors) {
+        if (backendHints.includes(name)) {
+            // eslint-disable-next-line no-console
+            console.warn(`removing requested execution provider "${name}" from session options because it is not available: ${err}`);
+        }
+    }
+    const filteredEps = eps.filter((i) => availableBackendNames.has(typeof i === 'string' ? i : i.name));
+    return [
+        backend,
+        new Proxy(options, {
+            get: (target, prop) => {
+                if (prop === 'executionProviders') {
+                    return filteredEps;
+                }
+                return Reflect.get(target, prop);
+            },
+        }),
+    ];
+};
+//# sourceMappingURL=backend-impl.js.map

runtime/vendor/onnxruntime-common/backend.js

@@ -0,0 +1,4 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+export { registerBackend } from './backend-impl.js';
+//# sourceMappingURL=backend.js.map

runtime/vendor/onnxruntime-common/env-impl.js

@@ -0,0 +1,25 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+import { version } from './version.js';
+let logLevelValue = 'warning';
+export const env = {
+    wasm: {},
+    webgl: {},
+    webgpu: {},
+    versions: { common: version },
+    set logLevel(value) {
+        if (value === undefined) {
+            return;
+        }
+        if (typeof value !== 'string' || ['verbose', 'info', 'warning', 'error', 'fatal'].indexOf(value) === -1) {
+            throw new Error(`Unsupported logging level: ${value}`);
+        }
+        logLevelValue = value;
+    },
+    get logLevel() {
+        return logLevelValue;
+    },
+};
+// set property 'logLevel' so that they can be correctly transferred to worker by `postMessage()`.
+Object.defineProperty(env, 'logLevel', { enumerable: true });
+//# sourceMappingURL=env-impl.js.map

runtime/vendor/onnxruntime-common/env.js

@@ -0,0 +1,8 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+import { env as envImpl } from './env-impl.js';
+/**
+ * Represent a set of flags as a global singleton.
+ */
+export const env = envImpl;
+//# sourceMappingURL=env.js.map

runtime/vendor/onnxruntime-common/index.js

@@ -0,0 +1,27 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+/**
+ * # ONNX Runtime JavaScript API
+ *
+ * ONNX Runtime JavaScript API is a unified API for all JavaScript usages, including the following NPM packages:
+ *
+ * - [onnxruntime-node](https://www.npmjs.com/package/onnxruntime-node)
+ * - [onnxruntime-web](https://www.npmjs.com/package/onnxruntime-web)
+ * - [onnxruntime-react-native](https://www.npmjs.com/package/onnxruntime-react-native)
+ *
+ * See also:
+ * - [Get Started](https://onnxruntime.ai/docs/get-started/with-javascript/)
+ * - [Inference examples](https://github.com/microsoft/onnxruntime-inference-examples/tree/main/js)
+ *
+ * @packageDocumentation
+ */
+export * from './backend.js';
+export * from './env.js';
+export * from './inference-session.js';
+export * from './tensor.js';
+export * from './tensor-conversion.js';
+export * from './tensor-factory.js';
+export * from './trace.js';
+export * from './onnx-model.js';
+export * from './onnx-value.js';
+//# sourceMappingURL=index.js.map

runtime/vendor/onnxruntime-common/inference-session-impl.js

@@ -0,0 +1,208 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+import { resolveBackendAndExecutionProviders } from './backend-impl.js';
+import { Tensor } from './tensor.js';
+import { TRACE_FUNC_BEGIN, TRACE_FUNC_END, TRACE_EVENT_BEGIN, TRACE_EVENT_END } from './trace.js';
+export class InferenceSession {
+    constructor(handler) {
+        this.handler = handler;
+    }
+    async run(feeds, arg1, arg2) {
+        TRACE_FUNC_BEGIN();
+        TRACE_EVENT_BEGIN('InferenceSession.run');
+        const fetches = {};
+        let options = {};
+        // check inputs
+        if (typeof feeds !== 'object' || feeds === null || feeds instanceof Tensor || Array.isArray(feeds)) {
+            throw new TypeError("'feeds' must be an object that use input names as keys and OnnxValue as corresponding values.");
+        }
+        let isFetchesEmpty = true;
+        // determine which override is being used
+        if (typeof arg1 === 'object') {
+            if (arg1 === null) {
+                throw new TypeError('Unexpected argument[1]: cannot be null.');
+            }
+            if (arg1 instanceof Tensor) {
+                throw new TypeError("'fetches' cannot be a Tensor");
+            }
+            if (Array.isArray(arg1)) {
+                if (arg1.length === 0) {
+                    throw new TypeError("'fetches' cannot be an empty array.");
+                }
+                isFetchesEmpty = false;
+                // output names
+                for (const name of arg1) {
+                    if (typeof name !== 'string') {
+                        throw new TypeError("'fetches' must be a string array or an object.");
+                    }
+                    if (this.outputNames.indexOf(name) === -1) {
+                        throw new RangeError(`'fetches' contains invalid output name: ${name}.`);
+                    }
+                    fetches[name] = null;
+                }
+                if (typeof arg2 === 'object' && arg2 !== null) {
+                    options = arg2;
+                }
+                else if (typeof arg2 !== 'undefined') {
+                    throw new TypeError("'options' must be an object.");
+                }
+            }
+            else {
+                // decide whether arg1 is fetches or options
+                // if any output name is present and its value is valid OnnxValue, we consider it fetches
+                let isFetches = false;
+                const arg1Keys = Object.getOwnPropertyNames(arg1);
+                for (const name of this.outputNames) {
+                    if (arg1Keys.indexOf(name) !== -1) {
+                        const v = arg1[name];
+                        if (v === null || v instanceof Tensor) {
+                            isFetches = true;
+                            isFetchesEmpty = false;
+                            fetches[name] = v;
+                        }
+                    }
+                }
+                if (isFetches) {
+                    if (typeof arg2 === 'object' && arg2 !== null) {
+                        options = arg2;
+                    }
+                    else if (typeof arg2 !== 'undefined') {
+                        throw new TypeError("'options' must be an object.");
+                    }
+                }
+                else {
+                    options = arg1;
+                }
+            }
+        }
+        else if (typeof arg1 !== 'undefined') {
+            throw new TypeError("Unexpected argument[1]: must be 'fetches' or 'options'.");
+        }
+        // check if all inputs are in feed
+        for (const name of this.inputNames) {
+            if (typeof feeds[name] === 'undefined') {
+                throw new Error(`input '${name}' is missing in 'feeds'.`);
+            }
+        }
+        // if no fetches is specified, we use the full output names list
+        if (isFetchesEmpty) {
+            for (const name of this.outputNames) {
+                fetches[name] = null;
+            }
+        }
+        // feeds, fetches and options are prepared
+        const results = await this.handler.run(feeds, fetches, options);
+        const returnValue = {};
+        for (const key in results) {
+            if (Object.hasOwnProperty.call(results, key)) {
+                const result = results[key];
+                if (result instanceof Tensor) {
+                    returnValue[key] = result;
+                }
+                else {
+                    returnValue[key] = new Tensor(result.type, result.data, result.dims);
+                }
+            }
+        }
+        TRACE_EVENT_END('InferenceSession.run');
+        TRACE_FUNC_END();
+        return returnValue;
+    }
+    async release() {
+        return this.handler.dispose();
+    }
+    static async create(arg0, arg1, arg2, arg3) {
+        TRACE_FUNC_BEGIN();
+        TRACE_EVENT_BEGIN('InferenceSession.create');
+        // either load from a file or buffer
+        let filePathOrUint8Array;
+        let options = {};
+        if (typeof arg0 === 'string') {
+            filePathOrUint8Array = arg0;
+            if (typeof arg1 === 'object' && arg1 !== null) {
+                options = arg1;
+            }
+            else if (typeof arg1 !== 'undefined') {
+                throw new TypeError("'options' must be an object.");
+            }
+        }
+        else if (arg0 instanceof Uint8Array) {
+            filePathOrUint8Array = arg0;
+            if (typeof arg1 === 'object' && arg1 !== null) {
+                options = arg1;
+            }
+            else if (typeof arg1 !== 'undefined') {
+                throw new TypeError("'options' must be an object.");
+            }
+        }
+        else if (arg0 instanceof ArrayBuffer ||
+            (typeof SharedArrayBuffer !== 'undefined' && arg0 instanceof SharedArrayBuffer)) {
+            const buffer = arg0;
+            let byteOffset = 0;
+            let byteLength = arg0.byteLength;
+            if (typeof arg1 === 'object' && arg1 !== null) {
+                options = arg1;
+            }
+            else if (typeof arg1 === 'number') {
+                byteOffset = arg1;
+                if (!Number.isSafeInteger(byteOffset)) {
+                    throw new RangeError("'byteOffset' must be an integer.");
+                }
+                if (byteOffset < 0 || byteOffset >= buffer.byteLength) {
+                    throw new RangeError(`'byteOffset' is out of range [0, ${buffer.byteLength}).`);
+                }
+                byteLength = arg0.byteLength - byteOffset;
+                if (typeof arg2 === 'number') {
+                    byteLength = arg2;
+                    if (!Number.isSafeInteger(byteLength)) {
+                        throw new RangeError("'byteLength' must be an integer.");
+                    }
+                    if (byteLength <= 0 || byteOffset + byteLength > buffer.byteLength) {
+                        throw new RangeError(`'byteLength' is out of range (0, ${buffer.byteLength - byteOffset}].`);
+                    }
+                    if (typeof arg3 === 'object' && arg3 !== null) {
+                        options = arg3;
+                    }
+                    else if (typeof arg3 !== 'undefined') {
+                        throw new TypeError("'options' must be an object.");
+                    }
+                }
+                else if (typeof arg2 !== 'undefined') {
+                    throw new TypeError("'byteLength' must be a number.");
+                }
+            }
+            else if (typeof arg1 !== 'undefined') {
+                throw new TypeError("'options' must be an object.");
+            }
+            filePathOrUint8Array = new Uint8Array(buffer, byteOffset, byteLength);
+        }
+        else {
+            throw new TypeError("Unexpected argument[0]: must be 'path' or 'buffer'.");
+        }
+        // resolve backend, update session options with validated EPs, and create session handler
+        const [backend, optionsWithValidatedEPs] = await resolveBackendAndExecutionProviders(options);
+        const handler = await backend.createInferenceSessionHandler(filePathOrUint8Array, optionsWithValidatedEPs);
+        TRACE_EVENT_END('InferenceSession.create');
+        TRACE_FUNC_END();
+        return new InferenceSession(handler);
+    }
+    startProfiling() {
+        this.handler.startProfiling();
+    }
+    endProfiling() {
+        this.handler.endProfiling();
+    }
+    get inputNames() {
+        return this.handler.inputNames;
+    }
+    get outputNames() {
+        return this.handler.outputNames;
+    }
+    get inputMetadata() {
+        return this.handler.inputMetadata;
+    }
+    get outputMetadata() {
+        return this.handler.outputMetadata;
+    }
+}
+//# sourceMappingURL=inference-session-impl.js.map

runtime/vendor/onnxruntime-common/inference-session.js

@@ -0,0 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+import { InferenceSession as InferenceSessionImpl } from './inference-session-impl.js';
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export const InferenceSession = InferenceSessionImpl;
+//# sourceMappingURL=inference-session.js.map

runtime/vendor/onnxruntime-common/onnx-model.js

@@ -0,0 +1,4 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+export {};
+//# sourceMappingURL=onnx-model.js.map

runtime/vendor/onnxruntime-common/onnx-value.js

@@ -0,0 +1,4 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+export {};
+//# sourceMappingURL=onnx-value.js.map

runtime/vendor/onnxruntime-common/tensor-conversion-impl.js

@@ -0,0 +1,195 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+/**
+ * implementation of Tensor.toDataURL()
+ */
+export const tensorToDataURL = (tensor, options) => {
+    const canvas = typeof document !== 'undefined' ? document.createElement('canvas') : new OffscreenCanvas(1, 1);
+    canvas.width = tensor.dims[3];
+    canvas.height = tensor.dims[2];
+    const pixels2DContext = canvas.getContext('2d');
+    if (pixels2DContext != null) {
+        // Default values for height and width & format
+        let width;
+        let height;
+        if (options?.tensorLayout !== undefined && options.tensorLayout === 'NHWC') {
+            width = tensor.dims[2];
+            height = tensor.dims[3];
+        }
+        else {
+            // Default layout is NCWH
+            width = tensor.dims[3];
+            height = tensor.dims[2];
+        }
+        const inputformat = options?.format !== undefined ? options.format : 'RGB';
+        const norm = options?.norm;
+        let normMean;
+        let normBias;
+        if (norm === undefined || norm.mean === undefined) {
+            normMean = [255, 255, 255, 255];
+        }
+        else {
+            if (typeof norm.mean === 'number') {
+                normMean = [norm.mean, norm.mean, norm.mean, norm.mean];
+            }
+            else {
+                normMean = [norm.mean[0], norm.mean[1], norm.mean[2], 0];
+                if (norm.mean[3] !== undefined) {
+                    normMean[3] = norm.mean[3];
+                }
+            }
+        }
+        if (norm === undefined || norm.bias === undefined) {
+            normBias = [0, 0, 0, 0];
+        }
+        else {
+            if (typeof norm.bias === 'number') {
+                normBias = [norm.bias, norm.bias, norm.bias, norm.bias];
+            }
+            else {
+                normBias = [norm.bias[0], norm.bias[1], norm.bias[2], 0];
+                if (norm.bias[3] !== undefined) {
+                    normBias[3] = norm.bias[3];
+                }
+            }
+        }
+        const stride = height * width;
+        // Default pointer assignments
+        let rTensorPointer = 0, gTensorPointer = stride, bTensorPointer = stride * 2, aTensorPointer = -1;
+        // Updating the pointer assignments based on the input image format
+        if (inputformat === 'RGBA') {
+            rTensorPointer = 0;
+            gTensorPointer = stride;
+            bTensorPointer = stride * 2;
+            aTensorPointer = stride * 3;
+        }
+        else if (inputformat === 'RGB') {
+            rTensorPointer = 0;
+            gTensorPointer = stride;
+            bTensorPointer = stride * 2;
+        }
+        else if (inputformat === 'RBG') {
+            rTensorPointer = 0;
+            bTensorPointer = stride;
+            gTensorPointer = stride * 2;
+        }
+        for (let i = 0; i < height; i++) {
+            for (let j = 0; j < width; j++) {
+                const R = (tensor.data[rTensorPointer++] - normBias[0]) * normMean[0]; // R value
+                const G = (tensor.data[gTensorPointer++] - normBias[1]) * normMean[1]; // G value
+                const B = (tensor.data[bTensorPointer++] - normBias[2]) * normMean[2]; // B value
+                const A = aTensorPointer === -1 ? 255 : (tensor.data[aTensorPointer++] - normBias[3]) * normMean[3]; // A value
+                pixels2DContext.fillStyle = 'rgba(' + R + ',' + G + ',' + B + ',' + A + ')';
+                pixels2DContext.fillRect(j, i, 1, 1);
+            }
+        }
+        if ('toDataURL' in canvas) {
+            return canvas.toDataURL();
+        }
+        else {
+            throw new Error('toDataURL is not supported');
+        }
+    }
+    else {
+        throw new Error('Can not access image data');
+    }
+};
+/**
+ * implementation of Tensor.toImageData()
+ */
+export const tensorToImageData = (tensor, options) => {
+    const pixels2DContext = typeof document !== 'undefined'
+        ? document.createElement('canvas').getContext('2d')
+        : new OffscreenCanvas(1, 1).getContext('2d');
+    let image;
+    if (pixels2DContext != null) {
+        // Default values for height and width & format
+        let width;
+        let height;
+        let channels;
+        if (options?.tensorLayout !== undefined && options.tensorLayout === 'NHWC') {
+            width = tensor.dims[2];
+            height = tensor.dims[1];
+            channels = tensor.dims[3];
+        }
+        else {
+            // Default layout is NCWH
+            width = tensor.dims[3];
+            height = tensor.dims[2];
+            channels = tensor.dims[1];
+        }
+        const inputformat = options !== undefined ? (options.format !== undefined ? options.format : 'RGB') : 'RGB';
+        const norm = options?.norm;
+        let normMean;
+        let normBias;
+        if (norm === undefined || norm.mean === undefined) {
+            normMean = [255, 255, 255, 255];
+        }
+        else {
+            if (typeof norm.mean === 'number') {
+                normMean = [norm.mean, norm.mean, norm.mean, norm.mean];
+            }
+            else {
+                normMean = [norm.mean[0], norm.mean[1], norm.mean[2], 255];
+                if (norm.mean[3] !== undefined) {
+                    normMean[3] = norm.mean[3];
+                }
+            }
+        }
+        if (norm === undefined || norm.bias === undefined) {
+            normBias = [0, 0, 0, 0];
+        }
+        else {
+            if (typeof norm.bias === 'number') {
+                normBias = [norm.bias, norm.bias, norm.bias, norm.bias];
+            }
+            else {
+                normBias = [norm.bias[0], norm.bias[1], norm.bias[2], 0];
+                if (norm.bias[3] !== undefined) {
+                    normBias[3] = norm.bias[3];
+                }
+            }
+        }
+        const stride = height * width;
+        if (options !== undefined) {
+            if ((options.format !== undefined && channels === 4 && options.format !== 'RGBA') ||
+                (channels === 3 && options.format !== 'RGB' && options.format !== 'BGR')) {
+                throw new Error("Tensor format doesn't match input tensor dims");
+            }
+        }
+        // Default pointer assignments
+        const step = 4;
+        let rImagePointer = 0, gImagePointer = 1, bImagePointer = 2, aImagePointer = 3;
+        let rTensorPointer = 0, gTensorPointer = stride, bTensorPointer = stride * 2, aTensorPointer = -1;
+        // Updating the pointer assignments based on the input image format
+        if (inputformat === 'RGBA') {
+            rTensorPointer = 0;
+            gTensorPointer = stride;
+            bTensorPointer = stride * 2;
+            aTensorPointer = stride * 3;
+        }
+        else if (inputformat === 'RGB') {
+            rTensorPointer = 0;
+            gTensorPointer = stride;
+            bTensorPointer = stride * 2;
+        }
+        else if (inputformat === 'RBG') {
+            rTensorPointer = 0;
+            bTensorPointer = stride;
+            gTensorPointer = stride * 2;
+        }
+        image = pixels2DContext.createImageData(width, height);
+        for (let i = 0; i < height * width; rImagePointer += step, gImagePointer += step, bImagePointer += step, aImagePointer += step, i++) {
+            image.data[rImagePointer] = (tensor.data[rTensorPointer++] - normBias[0]) * normMean[0]; // R value
+            image.data[gImagePointer] = (tensor.data[gTensorPointer++] - normBias[1]) * normMean[1]; // G value
+            image.data[bImagePointer] = (tensor.data[bTensorPointer++] - normBias[2]) * normMean[2]; // B value
+            image.data[aImagePointer] =
+                aTensorPointer === -1 ? 255 : (tensor.data[aTensorPointer++] - normBias[3]) * normMean[3]; // A value
+        }
+    }
+    else {
+        throw new Error('Can not access image data');
+    }
+    return image;
+};
+//# sourceMappingURL=tensor-conversion-impl.js.map

runtime/vendor/onnxruntime-common/tensor-conversion.js

@@ -0,0 +1,4 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+export {};
+//# sourceMappingURL=tensor-conversion.js.map

runtime/vendor/onnxruntime-common/tensor-factory-impl.js

@@ -0,0 +1,265 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+import { Tensor } from './tensor-impl.js';
+/**
+ * Create a new tensor object from image object
+ *
+ * @param buffer - Extracted image buffer data - assuming RGBA format
+ * @param imageFormat - input image configuration - required configurations height, width, format
+ * @param tensorFormat - output tensor configuration - Default is RGB format
+ */
+export const bufferToTensor = (buffer, options) => {
+    if (buffer === undefined) {
+        throw new Error('Image buffer must be defined');
+    }
+    if (options.height === undefined || options.width === undefined) {
+        throw new Error('Image height and width must be defined');
+    }
+    if (options.tensorLayout === 'NHWC') {
+        throw new Error('NHWC Tensor layout is not supported yet');
+    }
+    const { height, width } = options;
+    const norm = options.norm ?? { mean: 255, bias: 0 };
+    let normMean;
+    let normBias;
+    if (typeof norm.mean === 'number') {
+        normMean = [norm.mean, norm.mean, norm.mean, norm.mean];
+    }
+    else {
+        normMean = [norm.mean[0], norm.mean[1], norm.mean[2], norm.mean[3] ?? 255];
+    }
+    if (typeof norm.bias === 'number') {
+        normBias = [norm.bias, norm.bias, norm.bias, norm.bias];
+    }
+    else {
+        normBias = [norm.bias[0], norm.bias[1], norm.bias[2], norm.bias[3] ?? 0];
+    }
+    const inputformat = options.format !== undefined ? options.format : 'RGBA';
+    // default value is RGBA since imagedata and HTMLImageElement uses it
+    const outputformat = options.tensorFormat !== undefined ? (options.tensorFormat !== undefined ? options.tensorFormat : 'RGB') : 'RGB';
+    const stride = height * width;
+    const float32Data = outputformat === 'RGBA' ? new Float32Array(stride * 4) : new Float32Array(stride * 3);
+    // Default pointer assignments
+    let step = 4, rImagePointer = 0, gImagePointer = 1, bImagePointer = 2, aImagePointer = 3;
+    let rTensorPointer = 0, gTensorPointer = stride, bTensorPointer = stride * 2, aTensorPointer = -1;
+    // Updating the pointer assignments based on the input image format
+    if (inputformat === 'RGB') {
+        step = 3;
+        rImagePointer = 0;
+        gImagePointer = 1;
+        bImagePointer = 2;
+        aImagePointer = -1;
+    }
+    // Updating the pointer assignments based on the output tensor format
+    if (outputformat === 'RGBA') {
+        aTensorPointer = stride * 3;
+    }
+    else if (outputformat === 'RBG') {
+        rTensorPointer = 0;
+        bTensorPointer = stride;
+        gTensorPointer = stride * 2;
+    }
+    else if (outputformat === 'BGR') {
+        bTensorPointer = 0;
+        gTensorPointer = stride;
+        rTensorPointer = stride * 2;
+    }
+    for (let i = 0; i < stride; i++, rImagePointer += step, bImagePointer += step, gImagePointer += step, aImagePointer += step) {
+        float32Data[rTensorPointer++] = (buffer[rImagePointer] + normBias[0]) / normMean[0];
+        float32Data[gTensorPointer++] = (buffer[gImagePointer] + normBias[1]) / normMean[1];
+        float32Data[bTensorPointer++] = (buffer[bImagePointer] + normBias[2]) / normMean[2];
+        if (aTensorPointer !== -1 && aImagePointer !== -1) {
+            float32Data[aTensorPointer++] = (buffer[aImagePointer] + normBias[3]) / normMean[3];
+        }
+    }
+    // Float32Array -> ort.Tensor
+    const outputTensor = outputformat === 'RGBA'
+        ? new Tensor('float32', float32Data, [1, 4, height, width])
+        : new Tensor('float32', float32Data, [1, 3, height, width]);
+    return outputTensor;
+};
+/**
+ * implementation of Tensor.fromImage().
+ */
+export const tensorFromImage = async (image, options) => {
+    // checking the type of image object
+    const isHTMLImageEle = typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement;
+    const isImageDataEle = typeof ImageData !== 'undefined' && image instanceof ImageData;
+    const isImageBitmap = typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap;
+    const isString = typeof image === 'string';
+    let data;
+    let bufferToTensorOptions = options ?? {};
+    const createCanvas = () => {
+        if (typeof document !== 'undefined') {
+            return document.createElement('canvas');
+        }
+        else if (typeof OffscreenCanvas !== 'undefined') {
+            return new OffscreenCanvas(1, 1);
+        }
+        else {
+            throw new Error('Canvas is not supported');
+        }
+    };
+    const createCanvasContext = (canvas) => {
+        if (typeof HTMLCanvasElement !== 'undefined' && canvas instanceof HTMLCanvasElement) {
+            return canvas.getContext('2d');
+        }
+        else if (canvas instanceof OffscreenCanvas) {
+            return canvas.getContext('2d');
+        }
+        else {
+            return null;
+        }
+    };
+    // filling and checking image configuration options
+    if (isHTMLImageEle) {
+        // HTMLImageElement - image object - format is RGBA by default
+        const canvas = createCanvas();
+        canvas.width = image.width;
+        canvas.height = image.height;
+        const pixels2DContext = createCanvasContext(canvas);
+        if (pixels2DContext != null) {
+            let height = image.height;
+            let width = image.width;
+            if (options !== undefined && options.resizedHeight !== undefined && options.resizedWidth !== undefined) {
+                height = options.resizedHeight;
+                width = options.resizedWidth;
+            }
+            if (options !== undefined) {
+                bufferToTensorOptions = options;
+                if (options.tensorFormat !== undefined) {
+                    throw new Error('Image input config format must be RGBA for HTMLImageElement');
+                }
+                else {
+                    bufferToTensorOptions.tensorFormat = 'RGBA';
+                }
+                bufferToTensorOptions.height = height;
+                bufferToTensorOptions.width = width;
+            }
+            else {
+                bufferToTensorOptions.tensorFormat = 'RGBA';
+                bufferToTensorOptions.height = height;
+                bufferToTensorOptions.width = width;
+            }
+            pixels2DContext.drawImage(image, 0, 0);
+            data = pixels2DContext.getImageData(0, 0, width, height).data;
+        }
+        else {
+            throw new Error('Can not access image data');
+        }
+    }
+    else if (isImageDataEle) {
+        let height;
+        let width;
+        if (options !== undefined && options.resizedWidth !== undefined && options.resizedHeight !== undefined) {
+            height = options.resizedHeight;
+            width = options.resizedWidth;
+        }
+        else {
+            height = image.height;
+            width = image.width;
+        }
+        if (options !== undefined) {
+            bufferToTensorOptions = options;
+        }
+        bufferToTensorOptions.format = 'RGBA';
+        bufferToTensorOptions.height = height;
+        bufferToTensorOptions.width = width;
+        if (options !== undefined) {
+            const tempCanvas = createCanvas();
+            tempCanvas.width = width;
+            tempCanvas.height = height;
+            const pixels2DContext = createCanvasContext(tempCanvas);
+            if (pixels2DContext != null) {
+                pixels2DContext.putImageData(image, 0, 0);
+                data = pixels2DContext.getImageData(0, 0, width, height).data;
+            }
+            else {
+                throw new Error('Can not access image data');
+            }
+        }
+        else {
+            data = image.data;
+        }
+    }
+    else if (isImageBitmap) {
+        // ImageBitmap - image object - format must be provided by user
+        if (options === undefined) {
+            throw new Error('Please provide image config with format for Imagebitmap');
+        }
+        const canvas = createCanvas();
+        canvas.width = image.width;
+        canvas.height = image.height;
+        const pixels2DContext = createCanvasContext(canvas);
+        if (pixels2DContext != null) {
+            const height = image.height;
+            const width = image.width;
+            pixels2DContext.drawImage(image, 0, 0, width, height);
+            data = pixels2DContext.getImageData(0, 0, width, height).data;
+            bufferToTensorOptions.height = height;
+            bufferToTensorOptions.width = width;
+            return bufferToTensor(data, bufferToTensorOptions);
+        }
+        else {
+            throw new Error('Can not access image data');
+        }
+    }
+    else if (isString) {
+        return new Promise((resolve, reject) => {
+            const canvas = createCanvas();
+            const context = createCanvasContext(canvas);
+            if (!image || !context) {
+                return reject();
+            }
+            const newImage = new Image();
+            newImage.crossOrigin = 'Anonymous';
+            newImage.src = image;
+            newImage.onload = () => {
+                canvas.width = newImage.width;
+                canvas.height = newImage.height;
+                context.drawImage(newImage, 0, 0, canvas.width, canvas.height);
+                const img = context.getImageData(0, 0, canvas.width, canvas.height);
+                bufferToTensorOptions.height = canvas.height;
+                bufferToTensorOptions.width = canvas.width;
+                resolve(bufferToTensor(img.data, bufferToTensorOptions));
+            };
+        });
+    }
+    else {
+        throw new Error('Input data provided is not supported - aborted tensor creation');
+    }
+    if (data !== undefined) {
+        return bufferToTensor(data, bufferToTensorOptions);
+    }
+    else {
+        throw new Error('Input data provided is not supported - aborted tensor creation');
+    }
+};
+/**
+ * implementation of Tensor.fromTexture().
+ */
+export const tensorFromTexture = (texture, options) => {
+    const { width, height, download, dispose } = options;
+    // Always assume RGBAF32. TODO: support different texture format
+    const dims = [1, height, width, 4];
+    return new Tensor({ location: 'texture', type: 'float32', texture, dims, download, dispose });
+};
+/**
+ * implementation of Tensor.fromGpuBuffer().
+ */
+export const tensorFromGpuBuffer = (gpuBuffer, options) => {
+    const { dataType, dims, download, dispose } = options;
+    return new Tensor({ location: 'gpu-buffer', type: dataType ?? 'float32', gpuBuffer, dims, download, dispose });
+};
+/**
+ * implementation of Tensor.fromMLTensor().
+ */
+export const tensorFromMLTensor = (mlTensor, options) => {
+    const { dataType, dims, download, dispose } = options;
+    return new Tensor({ location: 'ml-tensor', type: dataType ?? 'float32', mlTensor, dims, download, dispose });
+};
+/**
+ * implementation of Tensor.fromPinnedBuffer().
+ */
+export const tensorFromPinnedBuffer = (type, buffer, dims) => new Tensor({ location: 'cpu-pinned', type, data: buffer, dims: dims ?? [buffer.length] });
+//# sourceMappingURL=tensor-factory-impl.js.map

runtime/vendor/onnxruntime-common/tensor-factory.js

@@ -0,0 +1,4 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+export {};
+//# sourceMappingURL=tensor-factory.js.map

runtime/vendor/onnxruntime-common/tensor-impl-type-mapping.js

@@ -0,0 +1,58 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+// a runtime map that maps type string to TypedArray constructor. Should match Tensor.DataTypeMap.
+export const NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP = new Map([
+    ['float32', Float32Array],
+    ['uint8', Uint8Array],
+    ['int8', Int8Array],
+    ['uint16', Uint16Array],
+    ['int16', Int16Array],
+    ['int32', Int32Array],
+    ['bool', Uint8Array],
+    ['float64', Float64Array],
+    ['uint32', Uint32Array],
+    ['int4', Uint8Array],
+    ['uint4', Uint8Array],
+]);
+// a runtime map that maps type string to TypedArray constructor. Should match Tensor.DataTypeMap.
+export const NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP = new Map([
+    [Float32Array, 'float32'],
+    [Uint8Array, 'uint8'],
+    [Int8Array, 'int8'],
+    [Uint16Array, 'uint16'],
+    [Int16Array, 'int16'],
+    [Int32Array, 'int32'],
+    [Float64Array, 'float64'],
+    [Uint32Array, 'uint32'],
+]);
+// the following code allows delaying execution of BigInt/Float16Array checking. This allows lazy initialization for
+// NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP and NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP, which allows BigInt/Float16Array
+// polyfill if available.
+let isTypedArrayChecked = false;
+export const checkTypedArray = () => {
+    if (!isTypedArrayChecked) {
+        isTypedArrayChecked = true;
+        const isBigInt64ArrayAvailable = typeof BigInt64Array !== 'undefined' && BigInt64Array.from;
+        const isBigUint64ArrayAvailable = typeof BigUint64Array !== 'undefined' && BigUint64Array.from;
+        // eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-explicit-any
+        const Float16Array = globalThis.Float16Array;
+        const isFloat16ArrayAvailable = typeof Float16Array !== 'undefined' && Float16Array.from;
+        if (isBigInt64ArrayAvailable) {
+            NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set('int64', BigInt64Array);
+            NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(BigInt64Array, 'int64');
+        }
+        if (isBigUint64ArrayAvailable) {
+            NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set('uint64', BigUint64Array);
+            NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(BigUint64Array, 'uint64');
+        }
+        if (isFloat16ArrayAvailable) {
+            NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set('float16', Float16Array);
+            NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(Float16Array, 'float16');
+        }
+        else {
+            // if Float16Array is not available, use 'Uint16Array' to store the data.
+            NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set('float16', Uint16Array);
+        }
+    }
+};
+//# sourceMappingURL=tensor-impl-type-mapping.js.map

runtime/vendor/onnxruntime-common/tensor-impl.js

@@ -0,0 +1,366 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+import { tensorToDataURL, tensorToImageData } from './tensor-conversion-impl.js';
+import { tensorFromGpuBuffer, tensorFromImage, tensorFromMLTensor, tensorFromPinnedBuffer, tensorFromTexture, } from './tensor-factory-impl.js';
+import { checkTypedArray, NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP, NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP, } from './tensor-impl-type-mapping.js';
+import { calculateSize, tensorReshape } from './tensor-utils-impl.js';
+/**
+ * the implementation of Tensor interface.
+ *
+ * @ignore
+ */
+export class Tensor {
+    /**
+     * implementation.
+     */
+    constructor(arg0, arg1, arg2) {
+        // perform one-time check for BigInt/Float16Array support
+        checkTypedArray();
+        let type;
+        let dims;
+        if (typeof arg0 === 'object' && 'location' in arg0) {
+            //
+            // constructing tensor from specific location
+            //
+            this.dataLocation = arg0.location;
+            type = arg0.type;
+            dims = arg0.dims;
+            switch (arg0.location) {
+                case 'cpu-pinned': {
+                    const expectedTypedArrayConstructor = NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.get(type);
+                    if (!expectedTypedArrayConstructor) {
+                        throw new TypeError(`unsupported type "${type}" to create tensor from pinned buffer`);
+                    }
+                    if (!(arg0.data instanceof expectedTypedArrayConstructor)) {
+                        throw new TypeError(`buffer should be of type ${expectedTypedArrayConstructor.name}`);
+                    }
+                    this.cpuData = arg0.data;
+                    break;
+                }
+                case 'texture': {
+                    if (type !== 'float32') {
+                        throw new TypeError(`unsupported type "${type}" to create tensor from texture`);
+                    }
+                    this.gpuTextureData = arg0.texture;
+                    this.downloader = arg0.download;
+                    this.disposer = arg0.dispose;
+                    break;
+                }
+                case 'gpu-buffer': {
+                    if (type !== 'float32' &&
+                        type !== 'float16' &&
+                        type !== 'int32' &&
+                        type !== 'int64' &&
+                        type !== 'uint32' &&
+                        type !== 'uint8' &&
+                        type !== 'bool' &&
+                        type !== 'uint4' &&
+                        type !== 'int4') {
+                        throw new TypeError(`unsupported type "${type}" to create tensor from gpu buffer`);
+                    }
+                    this.gpuBufferData = arg0.gpuBuffer;
+                    this.downloader = arg0.download;
+                    this.disposer = arg0.dispose;
+                    break;
+                }
+                case 'ml-tensor': {
+                    if (type !== 'float32' &&
+                        type !== 'float16' &&
+                        type !== 'int32' &&
+                        type !== 'int64' &&
+                        type !== 'uint32' &&
+                        type !== 'uint64' &&
+                        type !== 'int8' &&
+                        type !== 'uint8' &&
+                        type !== 'bool' &&
+                        type !== 'uint4' &&
+                        type !== 'int4') {
+                        throw new TypeError(`unsupported type "${type}" to create tensor from MLTensor`);
+                    }
+                    this.mlTensorData = arg0.mlTensor;
+                    this.downloader = arg0.download;
+                    this.disposer = arg0.dispose;
+                    break;
+                }
+                default:
+                    throw new Error(`Tensor constructor: unsupported location '${this.dataLocation}'`);
+            }
+        }
+        else {
+            //
+            // constructing tensor of location 'cpu'
+            //
+            let data;
+            let maybeDims;
+            // check whether arg0 is type or data
+            if (typeof arg0 === 'string') {
+                //
+                // Override: constructor(type, data, ...)
+                //
+                type = arg0;
+                maybeDims = arg2;
+                if (arg0 === 'string') {
+                    // string tensor
+                    if (!Array.isArray(arg1)) {
+                        throw new TypeError("A string tensor's data must be a string array.");
+                    }
+                    // we don't check whether every element in the array is string; this is too slow. we assume it's correct and
+                    // error will be populated at inference
+                    data = arg1;
+                }
+                else {
+                    // numeric tensor
+                    const typedArrayConstructor = NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.get(arg0);
+                    if (typedArrayConstructor === undefined) {
+                        throw new TypeError(`Unsupported tensor type: ${arg0}.`);
+                    }
+                    if (Array.isArray(arg1)) {
+                        if ((arg0 === 'float16' && typedArrayConstructor === Uint16Array) || arg0 === 'uint4' || arg0 === 'int4') {
+                            // - 'float16':
+                            //   When no Float16Array polyfill is used, we cannot create 'float16' tensor from number array.
+                            //
+                            //   Throw error here because when user try to use number array as data,
+                            //   e.g. new Tensor('float16', [1, 2, 3, 4], dims)), it will actually call
+                            //   Uint16Array.from(arg1) which generates wrong data.
+                            //
+                            // - 'uint4' and 'int4':
+                            //   Uint8Array.from(arg1) will generate wrong data for 'uint4' and 'int4' tensor.
+                            //
+                            throw new TypeError(`Creating a ${arg0} tensor from number array is not supported. Please use ${typedArrayConstructor.name} as data.`);
+                        }
+                        else if (arg0 === 'uint64' || arg0 === 'int64') {
+                            // use 'as any' here because:
+                            // 1. TypeScript's check on type of 'Array.isArray()' does not work with readonly arrays.
+                            // see https://github.com/microsoft/TypeScript/issues/17002
+                            // 2. TypeScript's check on union type of '(BigInt64ArrayConstructor|BigUint64ArrayConstructor).from()'
+                            // does not accept parameter mapFn.
+                            // 3. parameters of 'SupportedTypedArrayConstructors.from()' does not match the requirement of the union
+                            // type.
+                            // assume 'arg1' is of type "readonly number[]|readonly bigint[]" here.
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                            data = typedArrayConstructor.from(arg1, BigInt);
+                        }
+                        else {
+                            // assume 'arg1' is of type "readonly number[]" here.
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                            data = typedArrayConstructor.from(arg1);
+                        }
+                    }
+                    else if (arg1 instanceof typedArrayConstructor) {
+                        data = arg1;
+                    }
+                    else if (arg1 instanceof Uint8ClampedArray) {
+                        if (arg0 === 'uint8') {
+                            data = Uint8Array.from(arg1);
+                        }
+                        else {
+                            throw new TypeError(`A Uint8ClampedArray tensor's data must be type of uint8`);
+                        }
+                    }
+                    else if (arg0 === 'float16' && arg1 instanceof Uint16Array && typedArrayConstructor !== Uint16Array) {
+                        // when Float16Array is available and data is of type Uint16Array.
+                        // We allow Uint16Array to be passed in as data for 'float16' tensor until Float16Array is generally
+                        // supported in JavaScript environment.
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        data = new globalThis.Float16Array(arg1.buffer, arg1.byteOffset, arg1.length);
+                    }
+                    else {
+                        throw new TypeError(`A ${type} tensor's data must be type of ${typedArrayConstructor}`);
+                    }
+                }
+            }
+            else {
+                //
+                // Override: constructor(data, ...)
+                //
+                maybeDims = arg1;
+                if (Array.isArray(arg0)) {
+                    // only boolean[] and string[] is supported
+                    if (arg0.length === 0) {
+                        throw new TypeError('Tensor type cannot be inferred from an empty array.');
+                    }
+                    const firstElementType = typeof arg0[0];
+                    if (firstElementType === 'string') {
+                        type = 'string';
+                        data = arg0;
+                    }
+                    else if (firstElementType === 'boolean') {
+                        type = 'bool';
+                        // 'arg0' is of type 'boolean[]'. Uint8Array.from(boolean[]) actually works, but typescript thinks this is
+                        // wrong type. We use 'as any' to make it happy.
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        data = Uint8Array.from(arg0);
+                    }
+                    else {
+                        throw new TypeError(`Invalid element type of data array: ${firstElementType}.`);
+                    }
+                }
+                else if (arg0 instanceof Uint8ClampedArray) {
+                    type = 'uint8';
+                    data = Uint8Array.from(arg0);
+                }
+                else {
+                    // get tensor type from TypedArray
+                    const mappedType = NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.get(arg0.constructor);
+                    if (mappedType === undefined) {
+                        throw new TypeError(`Unsupported type for tensor data: ${arg0.constructor}.`);
+                    }
+                    type = mappedType;
+                    data = arg0;
+                }
+            }
+            // type and data is processed, now processing dims
+            if (maybeDims === undefined) {
+                // assume 1-D tensor if dims omitted
+                maybeDims = [data.length];
+            }
+            else if (!Array.isArray(maybeDims)) {
+                throw new TypeError("A tensor's dims must be a number array");
+            }
+            dims = maybeDims;
+            this.cpuData = data;
+            this.dataLocation = 'cpu';
+        }
+        // perform check on dims
+        const size = calculateSize(dims);
+        // if data is on CPU, check whether data length matches tensor size
+        if (this.cpuData && size !== this.cpuData.length) {
+            if ((type === 'uint4' || type === 'int4') && Math.ceil(size / 2) === this.cpuData.length) {
+                // for (u)int4, the data length is half of the tensor size. So we check this special case when size is odd.
+            }
+            else {
+                throw new Error(`Tensor's size(${size}) does not match data length(${this.cpuData.length}).`);
+            }
+        }
+        this.type = type;
+        this.dims = dims;
+        this.size = size;
+    }
+    // #endregion
+    // #region factory
+    static async fromImage(image, options) {
+        return tensorFromImage(image, options);
+    }
+    static fromTexture(texture, options) {
+        return tensorFromTexture(texture, options);
+    }
+    static fromGpuBuffer(gpuBuffer, options) {
+        return tensorFromGpuBuffer(gpuBuffer, options);
+    }
+    static fromMLTensor(mlTensor, options) {
+        return tensorFromMLTensor(mlTensor, options);
+    }
+    static fromPinnedBuffer(type, buffer, dims) {
+        return tensorFromPinnedBuffer(type, buffer, dims);
+    }
+    // #endregion
+    // #region conversions
+    toDataURL(options) {
+        return tensorToDataURL(this, options);
+    }
+    toImageData(options) {
+        return tensorToImageData(this, options);
+    }
+    // #endregion
+    // #region properties
+    get data() {
+        this.ensureValid();
+        if (!this.cpuData) {
+            throw new Error('The data is not on CPU. Use `getData()` to download GPU data to CPU, ' +
+                'or use `texture` or `gpuBuffer` property to access the GPU data directly.');
+        }
+        return this.cpuData;
+    }
+    get location() {
+        return this.dataLocation;
+    }
+    get texture() {
+        this.ensureValid();
+        if (!this.gpuTextureData) {
+            throw new Error('The data is not stored as a WebGL texture.');
+        }
+        return this.gpuTextureData;
+    }
+    get gpuBuffer() {
+        this.ensureValid();
+        if (!this.gpuBufferData) {
+            throw new Error('The data is not stored as a WebGPU buffer.');
+        }
+        return this.gpuBufferData;
+    }
+    get mlTensor() {
+        this.ensureValid();
+        if (!this.mlTensorData) {
+            throw new Error('The data is not stored as a WebNN MLTensor.');
+        }
+        return this.mlTensorData;
+    }
+    // #endregion
+    // #region methods
+    async getData(releaseData) {
+        this.ensureValid();
+        switch (this.dataLocation) {
+            case 'cpu':
+            case 'cpu-pinned':
+                return this.data;
+            case 'texture':
+            case 'gpu-buffer':
+            case 'ml-tensor': {
+                if (!this.downloader) {
+                    throw new Error('The current tensor is not created with a specified data downloader.');
+                }
+                if (this.isDownloading) {
+                    throw new Error('The current tensor is being downloaded.');
+                }
+                try {
+                    this.isDownloading = true;
+                    const data = await this.downloader();
+                    this.downloader = undefined;
+                    this.dataLocation = 'cpu';
+                    this.cpuData = data;
+                    if (releaseData && this.disposer) {
+                        this.disposer();
+                        this.disposer = undefined;
+                    }
+                    return data;
+                }
+                finally {
+                    this.isDownloading = false;
+                }
+            }
+            default:
+                throw new Error(`cannot get data from location: ${this.dataLocation}`);
+        }
+    }
+    dispose() {
+        if (this.isDownloading) {
+            throw new Error('The current tensor is being downloaded.');
+        }
+        if (this.disposer) {
+            this.disposer();
+            this.disposer = undefined;
+        }
+        this.cpuData = undefined;
+        this.gpuTextureData = undefined;
+        this.gpuBufferData = undefined;
+        this.mlTensorData = undefined;
+        this.downloader = undefined;
+        this.isDownloading = undefined;
+        this.dataLocation = 'none';
+    }
+    // #endregion
+    // #region tensor utilities
+    ensureValid() {
+        if (this.dataLocation === 'none') {
+            throw new Error('The tensor is disposed.');
+        }
+    }
+    reshape(dims) {
+        this.ensureValid();
+        if (this.downloader || this.disposer) {
+            throw new Error('Cannot reshape a tensor that owns GPU resource.');
+        }
+        return tensorReshape(this, dims);
+    }
+}
+//# sourceMappingURL=tensor-impl.js.map

runtime/vendor/onnxruntime-common/tensor-utils-impl.js

@@ -0,0 +1,62 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+import { Tensor } from './tensor-impl.js';
+/**
+ * calculate size from dims.
+ *
+ * @param dims the dims array. May be an illegal input.
+ */
+export const calculateSize = (dims) => {
+    let size = 1;
+    for (let i = 0; i < dims.length; i++) {
+        const dim = dims[i];
+        if (typeof dim !== 'number' || !Number.isSafeInteger(dim)) {
+            throw new TypeError(`dims[${i}] must be an integer, got: ${dim}`);
+        }
+        if (dim < 0) {
+            throw new RangeError(`dims[${i}] must be a non-negative integer, got: ${dim}`);
+        }
+        size *= dim;
+    }
+    return size;
+};
+/**
+ * implementation of Tensor.reshape()
+ */
+export const tensorReshape = (tensor, dims) => {
+    switch (tensor.location) {
+        case 'cpu':
+            return new Tensor(tensor.type, tensor.data, dims);
+        case 'cpu-pinned':
+            return new Tensor({
+                location: 'cpu-pinned',
+                data: tensor.data,
+                type: tensor.type,
+                dims,
+            });
+        case 'texture':
+            return new Tensor({
+                location: 'texture',
+                texture: tensor.texture,
+                type: tensor.type,
+                dims,
+            });
+        case 'gpu-buffer':
+            return new Tensor({
+                location: 'gpu-buffer',
+                gpuBuffer: tensor.gpuBuffer,
+                type: tensor.type,
+                dims,
+            });
+        case 'ml-tensor':
+            return new Tensor({
+                location: 'ml-tensor',
+                mlTensor: tensor.mlTensor,
+                type: tensor.type,
+                dims,
+            });
+        default:
+            throw new Error(`tensorReshape: tensor location ${tensor.location} is not supported`);
+    }
+};
+//# sourceMappingURL=tensor-utils-impl.js.map

runtime/vendor/onnxruntime-common/tensor-utils.js

@@ -0,0 +1,4 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+export {};
+//# sourceMappingURL=tensor-utils.js.map

runtime/vendor/onnxruntime-common/tensor.js

@@ -0,0 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+import { Tensor as TensorImpl } from './tensor-impl.js';
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export const Tensor = TensorImpl;
+//# sourceMappingURL=tensor.js.map

runtime/vendor/onnxruntime-common/trace.js

@@ -0,0 +1,69 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+import { env } from './env-impl.js';
+/**
+ * @ignore
+ */
+export const TRACE = (deviceType, label) => {
+    if (typeof env.trace === 'undefined' ? !env.wasm.trace : !env.trace) {
+        return;
+    }
+    // eslint-disable-next-line no-console
+    console.timeStamp(`${deviceType}::ORT::${label}`);
+};
+const TRACE_FUNC = (msg, extraMsg) => {
+    const stack = new Error().stack?.split(/\r\n|\r|\n/g) || [];
+    let hasTraceFunc = false;
+    for (let i = 0; i < stack.length; i++) {
+        if (hasTraceFunc && !stack[i].includes('TRACE_FUNC')) {
+            let label = `FUNC_${msg}::${stack[i].trim().split(' ')[1]}`;
+            if (extraMsg) {
+                label += `::${extraMsg}`;
+            }
+            TRACE('CPU', label);
+            return;
+        }
+        if (stack[i].includes('TRACE_FUNC')) {
+            hasTraceFunc = true;
+        }
+    }
+};
+/**
+ * @ignore
+ */
+export const TRACE_FUNC_BEGIN = (extraMsg) => {
+    if (typeof env.trace === 'undefined' ? !env.wasm.trace : !env.trace) {
+        return;
+    }
+    TRACE_FUNC('BEGIN', extraMsg);
+};
+/**
+ * @ignore
+ */
+export const TRACE_FUNC_END = (extraMsg) => {
+    if (typeof env.trace === 'undefined' ? !env.wasm.trace : !env.trace) {
+        return;
+    }
+    TRACE_FUNC('END', extraMsg);
+};
+/**
+ * @ignore
+ */
+export const TRACE_EVENT_BEGIN = (extraMsg) => {
+    if (typeof env.trace === 'undefined' ? !env.wasm.trace : !env.trace) {
+        return;
+    }
+    // eslint-disable-next-line no-console
+    console.time(`ORT::${extraMsg}`);
+};
+/**
+ * @ignore
+ */
+export const TRACE_EVENT_END = (extraMsg) => {
+    if (typeof env.trace === 'undefined' ? !env.wasm.trace : !env.trace) {
+        return;
+    }
+    // eslint-disable-next-line no-console
+    console.timeEnd(`ORT::${extraMsg}`);
+};
+//# sourceMappingURL=trace.js.map

runtime/vendor/onnxruntime-common/type-helper.js

@@ -0,0 +1,4 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+export {};
+//# sourceMappingURL=type-helper.js.map

runtime/vendor/onnxruntime-common/version.js

@@ -0,0 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+// This file is generated by /js/scripts/update-version.ts
+// Do not modify file content manually.
+export const version = '1.27.0';
+//# sourceMappingURL=version.js.map

runtime/vendor/ort-wasm-simd-threaded.asyncify.mjs

@@ -0,0 +1,112 @@
+async function ortWasmThreaded(moduleArg={}){var moduleRtn;var g=moduleArg,aa=!!globalThis.window,ba=!!globalThis.WorkerGlobalScope,l=globalThis.process?.versions?.node&&"renderer"!=globalThis.process?.type,n=ba&&self.name?.startsWith("em-pthread");if(l){const {createRequire:a}=await import("module");var require=a(import.meta.url),ca=require("worker_threads");global.Worker=ca.Worker;n=(ba=!ca.oe)&&"em-pthread"==ca.workerData}g.mountExternalData=(a,b)=>{a.startsWith("./")&&(a=a.substring(2));(g.Vc||(g.Vc=new Map)).set(a,b)};
+g.unmountExternalData=()=>{delete g.Vc};var SharedArrayBuffer=globalThis.SharedArrayBuffer??(new WebAssembly.Memory({initial:0,maximum:0,shared:!0})).buffer.constructor;
+let ea=()=>{const a=b=>(...c)=>{const d=q;c=b(...c);return q!=d?da():c};(b=>{for(const c of b)g[c]=a(g[c])})(["_OrtAppendExecutionProvider","_OrtCreateSession","_OrtRun","_OrtRunWithBinding","_OrtBindInput"]);"undefined"!==typeof jsepRunAsync&&(g._OrtRun=jsepRunAsync(g._OrtRun),g._OrtRunWithBinding=jsepRunAsync(g._OrtRunWithBinding));ea=void 0};g.asyncInit=()=>{ea?.()};var fa="./this.program",ha=(a,b)=>{throw b;},ia=import.meta.url,ja="",ka,la;
+if(l){var fs=require("fs");ia.startsWith("file:")&&(ja=require("path").dirname(require("url").fileURLToPath(ia))+"/");la=a=>{a=ma(a)?new URL(a):a;return fs.readFileSync(a)};ka=async a=>{a=ma(a)?new URL(a):a;return fs.readFileSync(a,void 0)};1<process.argv.length&&(fa=process.argv[1].replace(/\\/g,"/"));process.argv.slice(2);ha=(a,b)=>{process.exitCode=a;throw b;}}else if(aa||ba){try{ja=(new URL(".",ia)).href}catch{}l||(ba&&(la=a=>{var b=new XMLHttpRequest;b.open("GET",a,!1);b.responseType="arraybuffer";
+b.send(null);return new Uint8Array(b.response)}),ka=async a=>{if(ma(a))return new Promise((c,d)=>{var e=new XMLHttpRequest;e.open("GET",a,!0);e.responseType="arraybuffer";e.onload=()=>{200==e.status||0==e.status&&e.response?c(e.response):d(e.status)};e.onerror=d;e.send(null)});var b=await fetch(a,{credentials:"same-origin"});if(b.ok)return b.arrayBuffer();throw Error(b.status+" : "+b.url);})}var na=console.log.bind(console),oa=console.error.bind(console);
+if(l){var pa=require("util"),qa=a=>"object"==typeof a?pa.inspect(a):a;na=(...a)=>fs.writeSync(1,a.map(qa).join(" ")+"\n");oa=(...a)=>fs.writeSync(2,a.map(qa).join(" ")+"\n")}var ra=na,t=oa,sa,ta,ua=!1,va,ma=a=>a.startsWith("file://");function u(){v.buffer!=w.buffer&&wa()}var xa,ya;
+if(l&&n){var Aa=ca.parentPort;Aa.on("message",a=>global.onmessage?.({data:a}));Object.assign(globalThis,{self:global,postMessage:a=>Aa.postMessage(a)});process.on("uncaughtException",a=>{postMessage({Pc:"uncaughtException",error:a});process.exit(1)})}var Ba;
+if(n){var Ca=!1;self.onunhandledrejection=b=>{throw b.reason||b;};function a(b){try{var c=b.data,d=c.Pc;if("load"===d){let e=[];self.onmessage=f=>e.push(f);Ba=()=>{postMessage({Pc:"loaded"});for(let f of e)a(f);self.onmessage=a};for(const f of c.ee)if(!g[f]||g[f].proxy)g[f]=(...h)=>{postMessage({Pc:"callHandler",de:f,args:h})},"print"==f&&(ra=g[f]),"printErr"==f&&(t=g[f]);v=c.ke;wa();ta=c.le;Da();Ea()}else if("run"===d){Fa(c.Oc);Ga(c.Oc,0,0,1,0,0);Ha();Ia(c.Oc);Ca||(Ja(),Ca=!0);try{Ka(c.ie,c.Xc)}catch(e){if("unwind"!=
+e)throw e;}}else"setimmediate"!==c.target&&("checkMailbox"===d?Ca&&La():d&&(t(`worker: received unknown command ${d}`),t(c)))}catch(e){throw Ma(),e;}}self.onmessage=a}var w,x,Na,Oa,A,B,Pa,E,F,Qa,Ra=!1;function wa(){var a=v.buffer;g.HEAP8=w=new Int8Array(a);Na=new Int16Array(a);g.HEAPU8=x=new Uint8Array(a);Oa=new Uint16Array(a);g.HEAP32=A=new Int32Array(a);g.HEAPU32=B=new Uint32Array(a);Pa=new Float32Array(a);E=new Float64Array(a);F=new BigInt64Array(a);Qa=new BigUint64Array(a)}
+function Sa(){Ra=!0;n?Ba():G.$b()}function Ta(a){a="Aborted("+a+")";t(a);ua=!0;a=new WebAssembly.RuntimeError(a+". Build with -sASSERTIONS for more info.");ya?.(a);throw a;}var Ua;async function Va(a){if(!sa)try{var b=await ka(a);return new Uint8Array(b)}catch{}if(a==Ua&&sa)a=new Uint8Array(sa);else if(la)a=la(a);else throw"both async and sync fetching of the wasm failed";return a}
+async function Wa(a,b){try{var c=await Va(a);return await WebAssembly.instantiate(c,b)}catch(d){t(`failed to asynchronously prepare wasm: ${d}`),Ta(d)}}async function Xa(a){var b=Ua;if(!sa&&!ma(b)&&!l)try{var c=fetch(b,{credentials:"same-origin"});return await WebAssembly.instantiateStreaming(c,a)}catch(d){t(`wasm streaming compile failed: ${d}`),t("falling back to ArrayBuffer instantiation")}return Wa(b,a)}
+function Ya(){Za={f:$a,J:ab,k:bb,p:cb,l:db,sa:eb,b:fb,ca:gb,Ja:hb,q:ib,da:jb,Za:kb,Fa:lb,Ha:mb,_a:nb,Xa:ob,Qa:pb,Wa:qb,oa:rb,Ga:sb,Yb:tb,Ya:ub,Zb:vb,db:wb,Da:xb,Tb:zb,Rb:Ab,Ca:Cb,M:Db,I:Eb,Sb:Fb,ja:Gb,Ub:Hb,Ta:Ib,Wb:Jb,Ka:Kb,Pb:Lb,ka:Mb,Sa:Ia,ab:Nb,U:Ob,n:Pb,c:Qb,rb:Rb,w:Sb,L:Tb,z:Ub,j:Vb,o:Wb,sb:Xb,G:Yb,T:Zb,h:$b,u:ac,m:bc,i:cc,Na:dc,Oa:ec,Pa:fc,La:gc,Ma:hc,Qb:ic,eb:jc,cb:kc,Y:lc,qb:mc,la:nc,bb:oc,fb:pc,$a:qc,Xb:rc,N:sc,gb:tc,X:uc,Vb:vc,nb:wc,C:xc,ra:yc,qa:zc,pb:Ac,W:Bc,v:Cc,mb:Dc,lb:Ec,kb:Fc,ob:Gc,
+jb:Hc,ib:Ic,hb:Jc,Ua:Kc,Va:Lc,Ia:Mc,V:Nc,na:Oc,Ra:Pc,ma:Qc,Cb:Rc,xa:Sc,Db:Tc,ya:Uc,F:Vc,e:Wc,s:Xc,x:Yc,B:Zc,Fb:$c,ba:ad,D:bd,za:cd,$:dd,ga:ed,Gb:fd,Hb:gd,Ba:hd,Aa:jd,Ib:kd,wa:ld,aa:md,d:nd,A:od,r:pd,Bb:qd,t:rd,y:sd,H:td,E:ud,K:vd,R:wd,ia:xd,_:yd,Kb:zd,Lb:Ad,Jb:Bd,g:Cd,a:v,Ob:Dd,Eb:Ed,ha:Fd,O:Gd,pa:Hd,Mb:Id,ta:Jd,Q:Kd,yb:Ld,zb:Md,ua:Nd,ea:Od,P:Pd,Ea:Qd,va:Rd,Z:Sd,wb:Td,_b:Ud,S:Vd,Ab:Wd,tb:Xd,ub:Yd,vb:Zd,fa:$d,xb:ae,Nb:be};return{a:Za}}
+async function Da(){function a(d,e){var f=G=d.exports;d={};for(let [h,k]of Object.entries(f))"function"==typeof k?(f=ce(k),d[h]=f):d[h]=k;G=d;G=de();ee.push(G.jd);d=G;fe=d.ac;Ja=d.bc;g._OrtInit=d.cc;g._OrtGetLastError=d.dc;g._OrtCreateSessionOptions=d.ec;g._OrtAppendExecutionProvider=d.fc;g._OrtAddFreeDimensionOverride=d.gc;g._OrtAddSessionConfigEntry=d.hc;g._OrtReleaseSessionOptions=d.ic;g._OrtCreateSession=d.jc;g._OrtReleaseSession=d.kc;g._OrtGetInputOutputCount=d.lc;g._OrtGetInputOutputMetadata=
+d.mc;g._OrtFree=d.nc;g._OrtCreateTensor=d.oc;g._OrtGetTensorData=d.pc;g._OrtReleaseTensor=d.qc;g._OrtCreateRunOptions=d.rc;g._OrtAddRunConfigEntry=d.sc;g._OrtReleaseRunOptions=d.tc;g._OrtCreateBinding=d.uc;g._OrtBindInput=d.vc;g._OrtBindOutput=d.wc;g._OrtClearBoundOutputs=d.xc;g._OrtReleaseBinding=d.yc;g._OrtRunWithBinding=d.zc;g._OrtRun=d.Ac;g._OrtEndProfiling=d.Bc;ge=g._OrtGetWebGpuDevice=d.Cc;he=d.Dc;H=g._free=d.Ec;ie=g._malloc=d.Fc;je=g._wgpuBufferRelease=d.Gc;ke=g._wgpuCreateInstance=d.Hc;le=
+d.Ic;me=d.Jc;ne=d.Kc;oe=d.Lc;pe=d.Mc;qe=d.Qc;re=d._c;se=d.$c;te=d.ad;ue=d.cd;ve=d.dd;we=d.ed;xe=d.fd;ye=d.gd;ze=d.hd;Ae=d.id;Ga=d.ld;Ma=d.md;Be=d.nd;Ce=d.od;De=d.pd;Ee=d.qd;Fe=d.rd;Ge=d.sd;I=d.td;He=d.ud;Ie=d.vd;J=d.wd;Je=d.xd;K=d.yd;Ke=d.zd;Le=d.Ad;Me=d.Bd;Ne=d.Cd;dynCall_vii=d.Dd;Oe=d.Ed;dynCall_v=d.Fd;Pe=d.Gd;Qe=d.Hd;Re=d.Id;dynCall_iii=d.Jd;Se=d.Kd;Te=d.Ld;Ue=d.Md;dynCall_vi=d.Nd;Ve=d.Od;We=d.Pd;Xe=d.Qd;Ye=d.Rd;Ze=d.Sd;$e=d.Ud;af=d.Vd;bf=d.Wd;cf=d.Xd;df=d.Zd;ef=d._d;ff=d.$d;gf=d.ae;hf=d.be;jf=
+d.ce;kf=d.qe;lf=d.re;mf=d.se;nf=d.te;of=d.ue;pf=d.ve;qf=d.we;rf=d.xe;sf=d.ye;tf=d.ze;uf=d.Ae;vf=d.$e;wf=d.af;xf=d.bf;yf=d.cf;ta=e;return G}var b=Ya();if(g.instantiateWasm)return new Promise(d=>{g.instantiateWasm(b,(e,f)=>{d(a(e,f))})});if(n){var c=new WebAssembly.Instance(ta,Ya());return a(c,ta)}Ua??=g.locateFile?g.locateFile?g.locateFile("ort-wasm-simd-threaded.asyncify.wasm",ja):ja+"ort-wasm-simd-threaded.asyncify.wasm":(new URL("ort-wasm-simd-threaded.asyncify.wasm",import.meta.url)).href;
+return function(d){return a(d.instance,d.module)}(await Xa(b))}class zf{name="ExitStatus";constructor(a){this.message=`Program terminated with exit(${a})`;this.status=a}}
+var Af=a=>{a.terminate();a.onmessage=()=>{}},Bf=[],Cf=0,Df=null,Jf=a=>{0==Ef.length&&(Ff(),Gf(Ef[0]));var b=Ef.pop();if(!b)return 6;Hf.push(b);If[a.Oc]=b;b.Oc=a.Oc;var c={Pc:"run",ie:a.he,Xc:a.Xc,Oc:a.Oc};l&&b.unref();b.postMessage(c,a.Zc);return 0},L=0,M=(a,b,...c)=>{var d=16*c.length,e=K(),f=Je(d),h=f>>>3,k;for(k of c)"bigint"==typeof k?((u(),F)[h++>>>0]=1n,(u(),F)[h++>>>0]=k):((u(),F)[h++>>>0]=0n,(u(),E)[h++>>>0]=k);a=Be(a,0,d,f,b);J(e);return a};
+function Dd(a){if(n)return M(0,1,a);va=a;if(!(0<L)){for(var b of Hf)Af(b);for(b of Ef)Af(b);Ef=[];Hf=[];If={};ua=!0}ha(a,new zf(a))}function Kf(a){if(n)return M(1,0,a);Mc(a)}var Mc=a=>{va=a;if(n)throw Kf(a),"unwind";Dd(a)},Ef=[],Hf=[],ee=[],If={};function Lf(){for(var a=g.numThreads-1;a--;)Ff();Bf.push(async()=>{var b=Mf();Cf++;await b;Cf--;0==Cf&&Df&&(b=Df,Df=null,b())})}var Nf=a=>{var b=a.Oc;delete If[b];Ef.push(a);Hf.splice(Hf.indexOf(a),1);a.Oc=0;Ce(b)};function Ha(){ee.forEach(a=>a())}
+var Gf=a=>new Promise(b=>{a.onmessage=f=>{var h=f.data;f=h.Pc;if(h.Wc&&h.Wc!=he()){var k=If[h.Wc];k?k.postMessage(h,h.Zc):t(`Internal error! Worker sent a message "${f}" to target pthread ${h.Wc}, but that thread no longer exists!`)}else if("checkMailbox"===f)La();else if("spawnThread"===f)Jf(h);else if("cleanupThread"===f)N(()=>{Nf(If[h.je])});else if("loaded"===f)a.loaded=!0,l&&!a.Oc&&a.unref(),b(a);else if("setimmediate"===h.target)a.postMessage(h);else if("uncaughtException"===f)a.onerror(h.error);
+else if("callHandler"===f)g[h.de](...h.args);else f&&t(`worker sent an unknown command ${f}`)};a.onerror=f=>{t(`${"worker sent an error!"} ${f.filename}:${f.lineno}: ${f.message}`);throw f;};l&&(a.on("message",f=>a.onmessage({data:f})),a.on("error",f=>a.onerror(f)));var c=[],d=[],e;for(e of d)g.propertyIsEnumerable(e)&&c.push(e);a.postMessage({Pc:"load",ee:c,ke:v,le:ta})});async function Mf(){if(!n)return Promise.all(Ef.map(Gf))}
+function Ff(){var a=new Worker(new URL(import.meta.url),{type:"module",workerData:"em-pthread",name:"em-pthread"});Ef.push(a)}function Fa(a){var b=(u(),B)[a+52>>>2>>>0];a=(u(),B)[a+56>>>2>>>0];Ie(b,b-a);J(b)}var Ka=(a,b)=>{L=0;a=Oe(a,b);0<L?va=a:De(a)},v,Of=[],Pf=0,O=a=>-9007199254740992>a||9007199254740992<a?NaN:Number(a);function $a(a){a>>>=0;var b=new Qf(a);0==(u(),w)[b.Rc+12>>>0]&&(Rf(b,!0),Pf--);Sf(b,!1);Of.push(b);return Ne(a)}
+var Tf=0,ab=()=>{I(0,0);var a=Of.pop();Ke(a.Yc);Tf=0};function Rf(a,b){b=b?1:0;(u(),w)[a.Rc+12>>>0]=b}function Sf(a,b){b=b?1:0;(u(),w)[a.Rc+13>>>0]=b}class Qf{constructor(a){this.Yc=a;this.Rc=a-24}}var Uf=a=>{var b=Tf;if(!b)return He(0),0;var c=new Qf(b);(u(),B)[c.Rc+16>>>2>>>0]=b;var d=(u(),B)[c.Rc+4>>>2>>>0];if(!d)return He(0),b;for(var e of a){if(0===e||e===d)break;if(Me(e,d,c.Rc+16))return He(e),b}He(d);return b};function bb(){return Uf([])}function cb(a){return Uf([a>>>0])}
+function db(a,b,c,d){return Uf([a>>>0,b>>>0,c>>>0,d>>>0])}var eb=()=>{var a=Of.pop();a||Ta("no exception to throw");var b=a.Yc;0==(u(),w)[a.Rc+13>>>0]&&(Of.push(a),Sf(a,!0),Rf(a,!1),Pf++);Le(b);Tf=b;throw Tf;};function fb(a,b,c){a>>>=0;var d=new Qf(a);b>>>=0;c>>>=0;(u(),B)[d.Rc+16>>>2>>>0]=0;(u(),B)[d.Rc+4>>>2>>>0]=b;(u(),B)[d.Rc+8>>>2>>>0]=c;Le(a);Tf=a;Pf++;throw Tf;}var gb=()=>Pf;function Vf(a,b,c,d){return n?M(2,1,a,b,c,d):hb(a,b,c,d)}
+function hb(a,b,c,d){a>>>=0;b>>>=0;c>>>=0;d>>>=0;if(!globalThis.SharedArrayBuffer)return 6;var e=[];if(n&&0===e.length)return Vf(a,b,c,d);a={he:c,Oc:a,Xc:d,Zc:e};return n?(a.Pc="spawnThread",postMessage(a,e),0):Jf(a)}function ib(a){Tf||=a>>>0;throw Tf;}
+var Wf=globalThis.TextDecoder&&new TextDecoder,Xf=(a,b,c,d)=>{c=b+c;if(d)return c;for(;a[b]&&!(b>=c);)++b;return b},Yf=(a,b=0,c,d)=>{b>>>=0;c=Xf(a,b,c,d);if(16<c-b&&a.buffer&&Wf)return Wf.decode(a.buffer instanceof ArrayBuffer?a.subarray(b,c):a.slice(b,c));for(d="";b<c;){var e=a[b++];if(e&128){var f=a[b++]&63;if(192==(e&224))d+=String.fromCharCode((e&31)<<6|f);else{var h=a[b++]&63;e=224==(e&240)?(e&15)<<12|f<<6|h:(e&7)<<18|f<<12|h<<6|a[b++]&63;65536>e?d+=String.fromCharCode(e):(e-=65536,d+=String.fromCharCode(55296|
+e>>10,56320|e&1023))}}else d+=String.fromCharCode(e)}return d},Zf=(a,b,c)=>(a>>>=0)?Yf((u(),x),a,b,c):"";function jb(a,b,c){return n?M(3,1,a,b,c):0}function kb(a,b){if(n)return M(4,1,a,b)}function lb(a,b){if(n)return M(5,1,a,b)}function mb(a,b,c){if(n)return M(6,1,a,b,c)}function nb(a,b,c){return n?M(7,1,a,b,c):0}function ob(a,b){if(n)return M(8,1,a,b)}function pb(a,b,c){if(n)return M(9,1,a,b,c)}function qb(a,b,c,d){if(n)return M(10,1,a,b,c,d)}function rb(a,b,c,d){if(n)return M(11,1,a,b,c,d)}
+function sb(a,b,c,d){if(n)return M(12,1,a,b,c,d)}function tb(a){if(n)return M(13,1,a)}function ub(a,b){if(n)return M(14,1,a,b)}function vb(a,b,c){if(n)return M(15,1,a,b,c)}var wb=()=>Ta(""),P=a=>{a>>>=0;for(var b="";;){var c=(u(),x)[a++>>>0];if(!c)return b;b+=String.fromCharCode(c)}},$f={},ag={},bg={},cg=class extends Error{constructor(a){super(a);this.name="BindingError"}};
+function dg(a,b,c={}){var d=b.name;if(!a)throw new cg(`type "${d}" must have a positive integer typeid pointer`);if(ag.hasOwnProperty(a)){if(c.fe)return;throw new cg(`Cannot register type '${d}' twice`);}ag[a]=b;delete bg[a];$f.hasOwnProperty(a)&&(b=$f[a],delete $f[a],b.forEach(e=>e()))}function Q(a,b,c={}){return dg(a,b,c)}
+var eg=(a,b,c)=>{switch(b){case 1:return c?d=>(u(),w)[d>>>0]:d=>(u(),x)[d>>>0];case 2:return c?d=>(u(),Na)[d>>>1>>>0]:d=>(u(),Oa)[d>>>1>>>0];case 4:return c?d=>(u(),A)[d>>>2>>>0]:d=>(u(),B)[d>>>2>>>0];case 8:return c?d=>(u(),F)[d>>>3>>>0]:d=>(u(),Qa)[d>>>3>>>0];default:throw new TypeError(`invalid integer width (${b}): ${a}`);}};
+function xb(a,b,c,d,e){a>>>=0;c>>>=0;b=P(b>>>0);d=0n===d;let f=h=>h;if(d){const h=8*c;f=k=>BigInt.asUintN(h,k);e=f(e)}Q(a,{name:b,Nc:f,Tc:(h,k)=>{"number"==typeof k&&(k=BigInt(k));return k},Sc:eg(b,c,!d),Uc:null})}function zb(a,b,c,d){a>>>=0;b=P(b>>>0);Q(a,{name:b,Nc:function(e){return!!e},Tc:function(e,f){return f?c:d},Sc:function(e){return this.Nc((u(),x)[e>>>0])},Uc:null})}var fg=[],gg=[0,1,,1,null,1,!0,1,!1,1];function Qb(a){a>>>=0;9<a&&0===--gg[a+1]&&(gg[a]=void 0,fg.push(a))}
+var R=a=>{if(!a)throw new cg(`Cannot use deleted val. handle = ${a}`);return gg[a]},S=a=>{switch(a){case void 0:return 2;case null:return 4;case !0:return 6;case !1:return 8;default:const b=fg.pop()||gg.length;gg[b]=a;gg[b+1]=1;return b}};function hg(a){return this.Nc((u(),B)[a>>>2>>>0])}var ig={name:"emscripten::val",Nc:a=>{var b=R(a);Qb(a);return b},Tc:(a,b)=>S(b),Sc:hg,Uc:null};function Ab(a){return Q(a>>>0,ig)}
+var jg=(a,b)=>{switch(b){case 4:return function(c){return this.Nc((u(),Pa)[c>>>2>>>0])};case 8:return function(c){return this.Nc((u(),E)[c>>>3>>>0])};default:throw new TypeError(`invalid float width (${b}): ${a}`);}};function Cb(a,b,c){a>>>=0;c>>>=0;b=P(b>>>0);Q(a,{name:b,Nc:d=>d,Tc:(d,e)=>e,Sc:jg(b,c),Uc:null})}function Db(a,b,c,d,e){a>>>=0;c>>>=0;b=P(b>>>0);let f=k=>k;if(0===d){var h=32-8*c;f=k=>k<<h>>>h;e=f(e)}Q(a,{name:b,Nc:f,Tc:(k,m)=>m,Sc:eg(b,c,0!==d),Uc:null})}
+function Eb(a,b,c){function d(f){var h=(u(),B)[f>>>2>>>0];f=(u(),B)[f+4>>>2>>>0];return new e((u(),w).buffer,f,h)}a>>>=0;var e=[Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,BigInt64Array,BigUint64Array][b];c=P(c>>>0);Q(a,{name:c,Nc:d,Sc:d},{fe:!0})}
+var T=(a,b,c)=>{var d=(u(),x);b>>>=0;if(0<c){var e=b;c=b+c-1;for(var f=0;f<a.length;++f){var h=a.codePointAt(f);if(127>=h){if(b>=c)break;d[b++>>>0]=h}else if(2047>=h){if(b+1>=c)break;d[b++>>>0]=192|h>>6;d[b++>>>0]=128|h&63}else if(65535>=h){if(b+2>=c)break;d[b++>>>0]=224|h>>12;d[b++>>>0]=128|h>>6&63;d[b++>>>0]=128|h&63}else{if(b+3>=c)break;d[b++>>>0]=240|h>>18;d[b++>>>0]=128|h>>12&63;d[b++>>>0]=128|h>>6&63;d[b++>>>0]=128|h&63;f++}}d[b>>>0]=0;a=b-e}else a=0;return a},U=a=>{for(var b=0,c=0;c<a.length;++c){var d=
+a.charCodeAt(c);127>=d?b++:2047>=d?b+=2:55296<=d&&57343>=d?(b+=4,++c):b+=3}return b};
+function Fb(a,b){a>>>=0;b=P(b>>>0);Q(a,{name:b,Nc(c){var d=(u(),B)[c>>>2>>>0];d=Zf(c+4,d,!0);H(c);return d},Tc(c,d){d instanceof ArrayBuffer&&(d=new Uint8Array(d));var e="string"==typeof d;if(!(e||ArrayBuffer.isView(d)&&1==d.BYTES_PER_ELEMENT))throw new cg("Cannot pass non-string to std::string");var f=e?U(d):d.length;var h=ie(4+f+1),k=h+4;(u(),B)[h>>>2>>>0]=f;e?T(d,k,f+1):(u(),x).set(d,k>>>0);null!==c&&c.push(H,h);return h},Sc:hg,Uc(c){H(c)}})}
+var kg=globalThis.TextDecoder?new TextDecoder("utf-16le"):void 0,lg=(a,b,c)=>{a>>>=1;b=Xf((u(),Oa),a,b/2,c);if(16<b-a&&kg)return kg.decode((u(),Oa).slice(a,b));for(c="";a<b;++a){var d=(u(),Oa)[a>>>0];c+=String.fromCharCode(d)}return c},mg=(a,b,c)=>{c??=2147483647;if(2>c)return 0;c-=2;var d=b;c=c<2*a.length?c/2:a.length;for(var e=0;e<c;++e){var f=a.charCodeAt(e);(u(),Na)[b>>>1>>>0]=f;b+=2}(u(),Na)[b>>>1>>>0]=0;return b-d},ng=a=>2*a.length,og=(a,b,c)=>{var d="";a>>>=2;for(var e=0;!(e>=b/4);e++){var f=
+(u(),B)[a+e>>>0];if(!f&&!c)break;d+=String.fromCodePoint(f)}return d},pg=(a,b,c)=>{b>>>=0;c??=2147483647;if(4>c)return 0;var d=b;c=d+c-4;for(var e=0;e<a.length;++e){var f=a.codePointAt(e);65535<f&&e++;(u(),A)[b>>>2>>>0]=f;b+=4;if(b+4>c)break}(u(),A)[b>>>2>>>0]=0;return b-d},qg=a=>{for(var b=0,c=0;c<a.length;++c)65535<a.codePointAt(c)&&c++,b+=4;return b};
+function Gb(a,b,c){a>>>=0;b>>>=0;c>>>=0;c=P(c);if(2===b){var d=lg;var e=mg;var f=ng}else d=og,e=pg,f=qg;Q(a,{name:c,Nc:h=>{var k=(u(),B)[h>>>2>>>0];k=d(h+4,k*b,!0);H(h);return k},Tc:(h,k)=>{if("string"!=typeof k)throw new cg(`Cannot pass non-string to C++ string type ${c}`);var m=f(k),p=ie(4+m+b);(u(),B)[p>>>2>>>0]=m/b;e(k,p+4,m+b);null!==h&&h.push(H,p);return p},Sc:hg,Uc(h){H(h)}})}function Hb(a,b){a>>>=0;b=P(b>>>0);Q(a,{ge:!0,name:b,Nc:()=>{},Tc:()=>{}})}
+function Ib(a){Ga(a>>>0,!ba,1,!aa,131072,!1);Ha()}var N=a=>{if(!ua)try{if(a(),!(0<L))try{n?he()&&De(va):Mc(va)}catch(b){b instanceof zf||"unwind"==b||ha(1,b)}}catch(b){b instanceof zf||"unwind"==b||ha(1,b)}},rg=!Atomics.waitAsync||globalThis.navigator?.userAgent&&91>Number((navigator.userAgent.match(/Chrom(e|ium)\/([0-9]+)\./)||[])[2]);function Ia(a){a>>>=0;rg||(Atomics.waitAsync((u(),A),a>>>2,a).value.then(La),a+=128,Atomics.store((u(),A),a>>>2,1))}var La=()=>N(()=>{var a=he();a&&(Ia(a),Fe())});
+function Jb(a,b){a>>>=0;a==b>>>0?setTimeout(La):n?postMessage({Wc:a,Pc:"checkMailbox"}):(a=If[a])&&a.postMessage({Pc:"checkMailbox"})}var sg=[];function Kb(a,b,c,d,e){b>>>=0;e>>>=0;sg.length=0;c=e>>>3;for(d=e+d>>>3;c<d;){var f;(u(),F)[c++>>>0]?f=(u(),F)[c++>>>0]:f=(u(),E)[c++>>>0];sg.push(f)}return(b?tg[b]:ug[a])(...sg)}var Lb=()=>{L=0};function Mb(a){a>>>=0;n?postMessage({Pc:"cleanupThread",je:a}):Nf(If[a])}function Nb(a){l&&If[a>>>0].ref()}var vg=a=>{try{a()}catch(b){Ta(b)}};
+function ce(a){var b=(...c)=>{wg.push(a);try{return a(...c)}finally{ua||(wg.pop(),q&&1===xg&&0===wg.length&&(xg=0,L+=1,vg(wf),"undefined"!=typeof Fibers&&Fibers.De()))}};yg.set(a,b);return b}var xg=0,q=null,zg=0,wg=[],Ag=new Map,Bg=new Map,yg=new Map,Cg=0,Dg=null,Eg=[];function da(){return new Promise((a,b)=>{Dg={resolve:a,reject:b}})}
+function Fg(){var a=ie(65548),b=a+12;(u(),B)[a>>>2>>>0]=b;(u(),B)[a+4>>>2>>>0]=b+65536;b=wg[0];if(!Ag.has(b)){var c=Cg++;Ag.set(b,c);Bg.set(c,b)}b=Ag.get(b);(u(),A)[a+8>>>2>>>0]=b;return a}function Gg(){var a=(u(),A)[q+8>>>2>>>0];a=Bg.get(a);a=yg.get(a);--L;return a()}
+function Hg(a){if(!ua){if(0===xg){var b=!1,c=!1;a((d=0)=>{if(!ua&&(zg=d,b=!0,c)){xg=2;vg(()=>xf(q));"undefined"!=typeof MainLoop&&MainLoop.Yd&&MainLoop.resume();d=!1;try{var e=Gg()}catch(k){e=k,d=!0}var f=!1;if(!q){var h=Dg;h&&(Dg=null,(d?h.reject:h.resolve)(e),f=!0)}if(d&&!f)throw e;}});c=!0;b||(xg=1,q=Fg(),"undefined"!=typeof MainLoop&&MainLoop.Yd&&MainLoop.pause(),vg(()=>vf(q)))}else 2===xg?(xg=0,vg(yf),H(q),q=null,Eg.forEach(N)):Ta(`invalid state: ${xg}`);return zg}}var Ig=a=>Hg(b=>{a().then(b)});
+function Ob(a){a>>>=0;return Ig(async()=>{var b=await R(a);return S(b)})}var Jg=[],Kg=a=>{var b=Jg.length;Jg.push(a);return b},Lg=(a,b)=>{for(var c=Array(a),d=0;d<a;++d){var e=d,f=(u(),B)[b+4*d>>>2>>>0],h=ag[f];if(void 0===h)throw a=`parameter ${d}`,f=fe(f),b=P(f),H(f),new cg(`${a} has unknown type ${b}`);c[e]=h}return c},Mg=(a,b,c)=>{var d=[];a=a(d,c);d.length&&((u(),B)[b>>>2>>>0]=S(d));return a},Ng={},Og=a=>{var b=Ng[a];return void 0===b?P(a):b};
+function Pb(a,b,c){var [d,...e]=Lg(a,b>>>0);b=d.Tc.bind(d);var f=e.map(m=>m.Sc.bind(m));a--;var h={toValue:R};a=f.map((m,p)=>{var C=`argFromPtr${p}`;h[C]=m;return`${C}(args${p?"+"+8*p:""})`});switch(c){case 0:var k="toValue(handle)";break;case 2:k="new (toValue(handle))";break;case 3:k="";break;case 1:h.getStringOrSymbol=Og,k="toValue(handle)[getStringOrSymbol(methodName)]"}k+=`(${a})`;d.ge||(h.toReturnWire=b,h.emval_returnValue=Mg,k=`return emval_returnValue(toReturnWire, destructorsRef, ${k})`);
+k=`return function (handle, methodName, destructorsRef, args) {\n  ${k}\n  }`;c=(new Function(Object.keys(h),k))(...Object.values(h));k=`methodCaller<(${e.map(m=>m.name)}) => ${d.name}>`;return Kg(Object.defineProperty(c,"name",{value:k}))}function Rb(a,b){b>>>=0;a=R(a>>>0);b=R(b);return a==b}function Sb(a){a>>>=0;if(!a)return S(globalThis);a=Og(a);return S(globalThis[a])}function Tb(a){a=Og(a>>>0);return S(g[a])}function Ub(a,b){b>>>=0;a=R(a>>>0);b=R(b);return S(a[b])}
+function Vb(a){a>>>=0;9<a&&(gg[a+1]+=1)}function Wb(a,b,c,d,e){return Jg[a>>>0](b>>>0,c>>>0,d>>>0,e>>>0)}function Xb(a,b,c,d,e){return Wb(a>>>0,b>>>0,c>>>0,d>>>0,e>>>0)}function Yb(){return S([])}function Zb(a){a=R(a>>>0);for(var b=Array(a.length),c=0;c<a.length;c++)b[c]=a[c];return S(b)}function $b(a){return S(Og(a>>>0))}function ac(){return S({})}function bc(a){a>>>=0;for(var b=R(a);b.length;){var c=b.pop();b.pop()(c)}Qb(a)}function cc(a,b,c){b>>>=0;c>>>=0;a=R(a>>>0);b=R(b);c=R(c);a[b]=c}
+function dc(a,b){a=O(a);b>>>=0;a=new Date(1E3*a);(u(),A)[b>>>2>>>0]=a.getUTCSeconds();(u(),A)[b+4>>>2>>>0]=a.getUTCMinutes();(u(),A)[b+8>>>2>>>0]=a.getUTCHours();(u(),A)[b+12>>>2>>>0]=a.getUTCDate();(u(),A)[b+16>>>2>>>0]=a.getUTCMonth();(u(),A)[b+20>>>2>>>0]=a.getUTCFullYear()-1900;(u(),A)[b+24>>>2>>>0]=a.getUTCDay();a=(a.getTime()-Date.UTC(a.getUTCFullYear(),0,1,0,0,0,0))/864E5|0;(u(),A)[b+28>>>2>>>0]=a}
+var Pg=a=>0===a%4&&(0!==a%100||0===a%400),Qg=[0,31,60,91,121,152,182,213,244,274,305,335],Rg=[0,31,59,90,120,151,181,212,243,273,304,334];
+function ec(a,b){a=O(a);b>>>=0;a=new Date(1E3*a);(u(),A)[b>>>2>>>0]=a.getSeconds();(u(),A)[b+4>>>2>>>0]=a.getMinutes();(u(),A)[b+8>>>2>>>0]=a.getHours();(u(),A)[b+12>>>2>>>0]=a.getDate();(u(),A)[b+16>>>2>>>0]=a.getMonth();(u(),A)[b+20>>>2>>>0]=a.getFullYear()-1900;(u(),A)[b+24>>>2>>>0]=a.getDay();var c=(Pg(a.getFullYear())?Qg:Rg)[a.getMonth()]+a.getDate()-1|0;(u(),A)[b+28>>>2>>>0]=c;(u(),A)[b+36>>>2>>>0]=-(60*a.getTimezoneOffset());c=(new Date(a.getFullYear(),6,1)).getTimezoneOffset();var d=(new Date(a.getFullYear(),
+0,1)).getTimezoneOffset();a=(c!=d&&a.getTimezoneOffset()==Math.min(d,c))|0;(u(),A)[b+32>>>2>>>0]=a}
+function fc(a){a>>>=0;var b=new Date((u(),A)[a+20>>>2>>>0]+1900,(u(),A)[a+16>>>2>>>0],(u(),A)[a+12>>>2>>>0],(u(),A)[a+8>>>2>>>0],(u(),A)[a+4>>>2>>>0],(u(),A)[a>>>2>>>0],0),c=(u(),A)[a+32>>>2>>>0],d=b.getTimezoneOffset(),e=(new Date(b.getFullYear(),6,1)).getTimezoneOffset(),f=(new Date(b.getFullYear(),0,1)).getTimezoneOffset(),h=Math.min(f,e);0>c?(u(),A)[a+32>>>2>>>0]=Number(e!=f&&h==d):0<c!=(h==d)&&(e=Math.max(f,e),b.setTime(b.getTime()+6E4*((0<c?h:e)-d)));(u(),A)[a+24>>>2>>>0]=b.getDay();c=(Pg(b.getFullYear())?
+Qg:Rg)[b.getMonth()]+b.getDate()-1|0;(u(),A)[a+28>>>2>>>0]=c;(u(),A)[a>>>2>>>0]=b.getSeconds();(u(),A)[a+4>>>2>>>0]=b.getMinutes();(u(),A)[a+8>>>2>>>0]=b.getHours();(u(),A)[a+12>>>2>>>0]=b.getDate();(u(),A)[a+16>>>2>>>0]=b.getMonth();(u(),A)[a+20>>>2>>>0]=b.getYear();a=b.getTime();return BigInt(isNaN(a)?-1:a/1E3)}function gc(a,b,c,d,e,f,h){return n?M(16,1,a,b,c,d,e,f,h):-52}function hc(a,b,c,d,e,f){if(n)return M(17,1,a,b,c,d,e,f)}var Sg={},sc=()=>performance.timeOrigin+performance.now();
+function ic(a,b){if(n)return M(18,1,a,b);Sg[a]&&(clearTimeout(Sg[a].id),delete Sg[a]);if(!b)return 0;var c=setTimeout(()=>{delete Sg[a];N(()=>Ee(a,performance.timeOrigin+performance.now()))},b);Sg[a]={id:c,Ce:b};return 0}
+function jc(a,b,c,d){a>>>=0;b>>>=0;c>>>=0;d>>>=0;var e=(new Date).getFullYear(),f=(new Date(e,0,1)).getTimezoneOffset();e=(new Date(e,6,1)).getTimezoneOffset();var h=Math.max(f,e);(u(),B)[a>>>2>>>0]=60*h;(u(),A)[b>>>2>>>0]=Number(f!=e);b=k=>{var m=Math.abs(k);return`UTC${0<=k?"-":"+"}${String(Math.floor(m/60)).padStart(2,"0")}${String(m%60).padStart(2,"0")}`};a=b(f);b=b(e);e<f?(T(a,c,17),T(b,d,17)):(T(a,d,17),T(b,c,17))}var oc=()=>Date.now(),Tg=1;
+function kc(a,b,c){c>>>=0;if(!(0<=a&&3>=a))return 28;if(0===a)a=Date.now();else if(Tg)a=performance.timeOrigin+performance.now();else return 52;a=Math.round(1E6*a);(u(),F)[c>>>3>>>0]=BigInt(a);return 0}var Ug=[],Vg=(a,b)=>{Ug.length=0;for(var c;c=(u(),x)[a++>>>0];){var d=105!=c;d&=112!=c;b+=d&&b%8?4:0;Ug.push(112==c?(u(),B)[b>>>2>>>0]:106==c?(u(),F)[b>>>3>>>0]:105==c?(u(),A)[b>>>2>>>0]:(u(),E)[b>>>3>>>0]);b+=d?8:4}return Ug};function lc(a,b,c){a>>>=0;b=Vg(b>>>0,c>>>0);return tg[a](...b)}
+function mc(a,b,c){a>>>=0;b=Vg(b>>>0,c>>>0);return tg[a](...b)}var nc=()=>{};function pc(a,b){return t(Zf(a>>>0,b>>>0))}var qc=()=>{L+=1;throw"unwind";};function rc(){return 4294901760}var tc=()=>1,uc=()=>l?require("os").cpus().length:navigator.hardwareConcurrency;
+function vc(a){a>>>=0;var b=(u(),x).length;if(a<=b||4294901760<a)return!1;for(var c=1;4>=c;c*=2){var d=b*(1+.2/c);d=Math.min(d,a+100663296);a:{d=(Math.min(4294901760,65536*Math.ceil(Math.max(a,d)/65536))-v.buffer.byteLength+65535)/65536|0;try{v.grow(d);wa();var e=1;break a}catch(f){}e=void 0}if(e)return!0}return!1}
+var V=a=>{var b=U(a)+1,c=Je(b);T(a,c,b);return c},Wg=(a,b)=>{(u(),B)[a>>>2>>>0]=b;var c=(u(),B)[a>>>2>>>0];(u(),B)[a+4>>>2>>>0]=(b-c)/4294967296},Xg=a=>(u(),B)[a>>>2>>>0]+4294967296*(u(),A)[a+4>>>2>>>0],W=[],Yg=(a,b)=>{W[a>>>0]=b},X=[],Zg=[],$g=(a,b)=>{Zg[a]=new Promise(c=>b.finally(()=>c(a)))},Y=a=>{if(a)return W[a>>>0]},ah=(a,b=0)=>{"unmapped"===a.mapState||Ta();b=re(b);W[b>>>0]=a;return b},bh=(a,b=0)=>{var c=te(b);b=se(b,c);W[c>>>0]=a.queue;W[b>>>0]=a;return b},ch=(a,b)=>{for(a=(u(),B)[a>>>2>>>
+0];a;a=(u(),B)[a>>>2>>>0]){var c=(u(),A)[a+4>>>2>>>0];b[c](a)}},dh=(a,b,c)=>{(u(),B)[a>>>2>>>0]=b;(u(),B)[a+4>>>2>>>0]=c},eh=a=>{var b=(u(),B)[a>>>2>>>0];a=(u(),B)[a+4>>>2>>>0];return Zf(b,a)},Z=a=>{var b=(u(),B)[a>>>2>>>0];a=(u(),B)[a+4>>>2>>>0];if(b)return Zf(b,a);if(0===a)return""},fh=a=>{var b=Z(a+4);var c=(c=(u(),B)[a+12>>>2>>>0])?Y(c):"auto";if(a+=16){var d=Y((u(),B)[a+4>>>2>>>0]);var e=(u(),B)[a+16>>>2>>>0];var f=(u(),B)[a+20>>>2>>>0];if(e){for(var h={},k=0;k<e;++k){var m=f+24*k,p=eh(m+4);
+h[p]=(u(),E)[m+16>>>3>>>0]}e=h}else e=void 0;a={module:d,constants:e,entryPoint:Z(a+8)}}else a=void 0;return{label:b,layout:c,compute:a}},gh=(a,b)=>{function c(d,e){d=a[d];(u(),B)[b+e>>>2>>>0]=d}c("maxTextureDimension1D",4);c("maxTextureDimension2D",8);c("maxTextureDimension3D",12);c("maxTextureArrayLayers",16);c("maxBindGroups",20);c("maxBindGroupsPlusVertexBuffers",24);c("maxBindingsPerBindGroup",28);c("maxDynamicUniformBuffersPerPipelineLayout",32);c("maxDynamicStorageBuffersPerPipelineLayout",
+36);c("maxSampledTexturesPerShaderStage",40);c("maxSamplersPerShaderStage",44);c("maxStorageBuffersPerShaderStage",48);c("maxStorageTexturesPerShaderStage",52);c("maxUniformBuffersPerShaderStage",56);c("minUniformBufferOffsetAlignment",80);c("minStorageBufferOffsetAlignment",84);Wg(b+64,a.maxUniformBufferBindingSize);Wg(b+72,a.maxStorageBufferBindingSize);c("maxVertexBuffers",88);Wg(b+96,a.maxBufferSize);c("maxVertexAttributes",104);c("maxVertexBufferArrayStride",108);c("maxInterStageShaderVariables",
+112);c("maxColorAttachments",116);c("maxColorAttachmentBytesPerSample",120);c("maxComputeWorkgroupStorageSize",124);c("maxComputeInvocationsPerWorkgroup",128);c("maxComputeWorkgroupSizeX",132);c("maxComputeWorkgroupSizeY",136);c("maxComputeWorkgroupSizeZ",140);c("maxComputeWorkgroupsPerDimension",144);void 0!==a.Be&&c("maxImmediateSize",148)},hh=[,"validation","out-of-memory","internal"],ih=[,"compatibility","core"],jh={1:"core-features-and-limits",2:"depth-clip-control",3:"depth32float-stencil8",
+4:"texture-compression-bc",5:"texture-compression-bc-sliced-3d",6:"texture-compression-etc2",7:"texture-compression-astc",8:"texture-compression-astc-sliced-3d",9:"timestamp-query",10:"indirect-first-instance",11:"shader-f16",12:"rg11b10ufloat-renderable",13:"bgra8unorm-storage",14:"float32-filterable",15:"float32-blendable",16:"clip-distances",17:"dual-source-blending",18:"subgroups",19:"texture-formats-tier1",20:"texture-formats-tier2",21:"primitive-index",22:"texture-component-swizzle",327692:"chromium-experimental-unorm16-texture-formats",
+327729:"chromium-experimental-multi-draw-indirect"},kh=[,"low-power","high-performance"],lh=[,"occlusion","timestamp"],mh={undefined:1,unknown:1,destroyed:2};
+function wc(a,b,c,d,e,f){b=O(b);c=O(c);d>>>=0;e>>>=0;f>>>=0;var h=Y(a>>>0);a={};if(f){var k=(u(),B)[f+12>>>2>>>0];if(k){var m=(u(),B)[f+16>>>2>>>0];a.requiredFeatures=Array.from((u(),B).subarray(m>>>2>>>0,m+4*k>>>2>>>0),r=>jh[r])}var p=(u(),B)[f+20>>>2>>>0];if(p){var C={};function r(z,D,za=!1){D=p+D;D=(u(),B)[D>>>2>>>0];4294967295==D||za&&0==D||(C[z]=D)}function y(z,D){D=p+D;var za=(u(),B)[D>>>2>>>0],yb=(u(),B)[D+4>>>2>>>0];if(4294967295!=za||4294967295!=yb)C[z]=Xg(D)}r("maxTextureDimension1D",4);
+r("maxTextureDimension2D",8);r("maxTextureDimension3D",12);r("maxTextureArrayLayers",16);r("maxBindGroups",20);r("maxBindGroupsPlusVertexBuffers",24);r("maxDynamicUniformBuffersPerPipelineLayout",32);r("maxDynamicStorageBuffersPerPipelineLayout",36);r("maxSampledTexturesPerShaderStage",40);r("maxSamplersPerShaderStage",44);r("maxStorageBuffersPerShaderStage",48);r("maxStorageTexturesPerShaderStage",52);r("maxUniformBuffersPerShaderStage",56);r("minUniformBufferOffsetAlignment",80);r("minStorageBufferOffsetAlignment",
+84);y("maxUniformBufferBindingSize",64);y("maxStorageBufferBindingSize",72);r("maxVertexBuffers",88);y("maxBufferSize",96);r("maxVertexAttributes",104);r("maxVertexBufferArrayStride",108);r("maxInterStageShaderVariables",112);r("maxColorAttachments",116);r("maxColorAttachmentBytesPerSample",120);r("maxComputeWorkgroupStorageSize",124);r("maxComputeInvocationsPerWorkgroup",128);r("maxComputeWorkgroupSizeX",132);r("maxComputeWorkgroupSizeY",136);r("maxComputeWorkgroupSizeZ",140);r("maxComputeWorkgroupsPerDimension",
+144);r("maxImmediateSize",148,!0);a.requiredLimits=C}if(k=(u(),B)[f+24>>>2>>>0])k={label:Z(k+4)},a.defaultQueue=k;a.label=Z(f+4)}L+=1;$g(b,h.requestDevice(a).then(r=>{--L;N(()=>{W[e>>>0]=r.queue;W[d>>>0]=r;L+=1;$g(c,r.lost.then(y=>{N(()=>{r.onuncapturederror=()=>{};var z=K(),D=V(y.message);ve(c,mh[y.reason],D);J(z)});--L}));r.onuncapturederror=y=>{var z=5;y.error instanceof GPUValidationError?z=2:y.error instanceof GPUOutOfMemoryError?z=3:y.error instanceof GPUInternalError&&(z=4);var D=K();y=V(y.error.message);
+Ae(d,z,y);J(D)};"adapterInfo"in r||(r.adapterInfo=h.info);ze(b,1,d,0)})},r=>{--L;N(()=>{var y=K(),z=V(r.message);ze(b,3,d,z);c&&ve(c,4,z);J(y)})}))}function xc(a){a>>>=0;var b=Y(a),c=X[a];if(c){for(var d=0;d<c.length;++d)c[d]();delete X[a]}b.destroy()}function yc(a,b,c){a>>>=0;c>>>=0;var d=Y(a);4294967295==c&&(c=void 0);try{var e=d.getMappedRange(b>>>0,c)}catch(h){return 0}var f=Ge(16,e.byteLength);(u(),x).set(new Uint8Array(e),f>>>0);X[a].push(()=>H(f));return f}
+function zc(a,b,c){a>>>=0;c>>>=0;var d=Y(a);4294967295==c&&(c=void 0);try{var e=d.getMappedRange(b>>>0,c)}catch(h){return 0}var f=Ge(16,e.byteLength);(u(),x).fill(0,f,e.byteLength);X[a].push(()=>{(new Uint8Array(e)).set((u(),x).subarray(f>>>0,f+e.byteLength>>>0));H(f)});return f}
+function Ac(a,b,c,d,e){a>>>=0;b=O(b);c=O(c);e>>>=0;var f=Y(a);X[a]=[];4294967295==e&&(e=void 0);L+=1;$g(b,f.mapAsync(c,d>>>0,e).then(()=>{--L;N(()=>{we(b,1,0)})},h=>{--L;N(()=>{K();var k=V(h.message);we(b,"AbortError"===h.name?4:"OperationError"===h.name?3:0,k);delete X[a]})}))}function Bc(a){a>>>=0;var b=Y(a),c=X[a];if(c){for(var d=0;d<c.length;++d)c[d]();delete X[a];b.unmap()}}function Cc(a){delete W[a>>>0]}
+function Dc(a,b,c){a>>>=0;b>>>=0;c>>>=0;var d=!!(u(),B)[b+32>>>2>>>0];b={label:Z(b+4),usage:(u(),B)[b+16>>>2>>>0],size:Xg(b+24),mappedAtCreation:d};a=Y(a);try{var e=a.createBuffer(b)}catch(f){return!1}W[c>>>0]=e;d&&(X[c]=[]);return!0}function Ec(a,b,c,d){a>>>=0;b=O(b);d>>>=0;c=fh(c>>>0);a=Y(a);L+=1;$g(b,a.createComputePipelineAsync(c).then(e=>{--L;N(()=>{W[d>>>0]=e;ue(b,1,d,0)})},e=>{--L;N(()=>{var f=K(),h=V(e.message);ue(b,"validation"===e.reason?3:"internal"===e.reason?4:0,d,h);J(f)})}))}
+function Fc(a,b,c){a>>>=0;b>>>=0;c>>>=0;var d=(u(),B)[b>>>2>>>0],e=(u(),A)[d+4>>>2>>>0];b={label:Z(b+4),code:""};switch(e){case 2:b.code=eh(d+8)}a=Y(a).createShaderModule(b);W[c>>>0]=a}var Gc=a=>{a=Y(a);a.onuncapturederror=null;a.destroy()};
+function Hc(a,b){b=O(b);a=Y(a>>>0);L+=1;$g(b,a.popErrorScope().then(c=>{--L;N(()=>{var d=5;c?c instanceof GPUValidationError?d=2:c instanceof GPUOutOfMemoryError?d=3:c instanceof GPUInternalError&&(d=4):d=1;var e=K(),f=c?V(c.message):0;xe(b,1,d,f);J(e)})},c=>{--L;N(()=>{var d=K(),e=V(c.message);xe(b,1,5,e);J(d)})}))}
+function Ic(a,b,c,d){b=O(b);c>>>=0;d>>>=0;if(c){var e={featureLevel:ih[(u(),A)[c+4>>>2>>>0]],powerPreference:kh[(u(),A)[c+8>>>2>>>0]],forceFallbackAdapter:!!(u(),B)[c+12>>>2>>>0]};a=(u(),B)[c>>>2>>>0];0!==a&&(u(),e.Fe=!!(u(),B)[a+8>>>2>>>0])}"gpu"in navigator?(L+=1,$g(b,navigator.gpu.requestAdapter(e).then(f=>{--L;N(()=>{if(f)W[d>>>0]=f,ye(b,1,d,0);else{var h=K(),k=V("WebGPU not available on this browser (requestAdapter returned null)");ye(b,3,d,k);J(h)}})},f=>{--L;N(()=>{var h=K(),k=V(f.message);
+ye(b,4,d,k);J(h)})}))):(e=K(),a=V("WebGPU not available on this browser (navigator.gpu is not available)"),ye(b,3,d,a),J(e))}function Jc(a,b,c){a>>>=0;b>>>=0;c>>>=0;return Ig(async()=>{var d=[];if(c){var e=(u(),A)[c>>>2>>>0];d.length=b+1;d[b]=new Promise(k=>setTimeout(k,e,0))}else d.length=b;for(var f=0;f<b;++f){var h=Xg(a+8*f);if(!(h in Zg))return h;d[f]=Zg[h]}d=await Promise.race(d);delete Zg[d];return d})}
+var nh={},ph=()=>{if(!oh){var a={USER:"web_user",LOGNAME:"web_user",PATH:"/",PWD:"/",HOME:"/home/web_user",LANG:(globalThis.navigator?.language??"C").replace("-","_")+".UTF-8",_:fa||"./this.program"},b;for(b in nh)void 0===nh[b]?delete a[b]:a[b]=nh[b];var c=[];for(b in a)c.push(`${b}=${a[b]}`);oh=c}return oh},oh;function Kc(a,b){if(n)return M(19,1,a,b);a>>>=0;b>>>=0;var c=0,d=0,e;for(e of ph()){var f=b+c;(u(),B)[a+d>>>2>>>0]=f;c+=T(e,f,Infinity)+1;d+=4}return 0}
+function Lc(a,b){if(n)return M(20,1,a,b);a>>>=0;b>>>=0;var c=ph();(u(),B)[a>>>2>>>0]=c.length;a=0;for(var d of c)a+=U(d)+1;(u(),B)[b>>>2>>>0]=a;return 0}function Nc(a){return n?M(21,1,a):52}function Oc(a,b,c,d){return n?M(22,1,a,b,c,d):52}function Pc(a,b,c,d){return n?M(23,1,a,b,c,d):70}var qh=[null,[],[]];
+function Qc(a,b,c,d){if(n)return M(24,1,a,b,c,d);b>>>=0;c>>>=0;d>>>=0;for(var e=0,f=0;f<c;f++){var h=(u(),B)[b>>>2>>>0],k=(u(),B)[b+4>>>2>>>0];b+=8;for(var m=0;m<k;m++){var p=a,C=(u(),x)[h+m>>>0],r=qh[p];0===C||10===C?((1===p?ra:t)(Yf(r)),r.length=0):r.push(C)}e+=k}(u(),B)[d>>>2>>>0]=e;return 0}function Cd(a){return a>>>0}function Ed(a,b){gh(Y(a>>>0).limits,b>>>0);return 1}function Fd(a,b){return Y(a>>>0).features.has(jh[b])}function Gd(a){return BigInt(Y(a>>>0).size)}
+function Hd(a){return BigInt(Y(a>>>0).usage)}function Id(a,b){a>>>=0;b>>>=0;if(b){var c=Z(b+4);b=(u(),B)[b+12>>>2>>>0];b=0!==b?{querySet:Y((u(),B)[b+4>>>2>>>0]),beginningOfPassWriteIndex:(u(),B)[b+8>>>2>>>0],endOfPassWriteIndex:(u(),B)[b+12>>>2>>>0]}:void 0;c={label:c,timestampWrites:b}}b=Y(a);a=pe(0);c=b.beginComputePass(c);W[a>>>0]=c;return a}function Jd(a,b,c,d){c=O(c);d=O(d);a=Y(a>>>0);-1==d&&(d=void 0);a.clearBuffer(Y(b>>>0),c,d)}
+function Kd(a,b,c,d,e,f){c=O(c);e=O(e);f=O(f);Y(a>>>0).copyBufferToBuffer(Y(b>>>0),c,Y(d>>>0),e,f)}function Ld(a){var b=Y(a>>>0);a=ne(0);b=b.finish();W[a>>>0]=b;return a}function Md(a,b,c,d,e,f){f=O(f);Y(a>>>0).resolveQuerySet(Y(b>>>0),c,d,Y(e>>>0),f)}function Nd(a,b,c,d){Y(a>>>0).dispatchWorkgroups(b,c,d)}function Od(a,b,c){c=O(c);Y(a>>>0).dispatchWorkgroupsIndirect(Y(b>>>0),c)}function Pd(a){Y(a>>>0).end()}
+function Qd(a,b,c,d,e){d>>>=0;e>>>=0;a=Y(a>>>0);c=Y(c>>>0);0==d?a.setBindGroup(b,c):a.setBindGroup(b,c,(u(),B),e>>>2,d)}function Rd(a,b){Y(a>>>0).setPipeline(Y(b>>>0))}function Sd(a,b,c){Y(a>>>0).Ee(Y(b>>>0),c)}function Td(a,b){var c=Y(a>>>0);a=me(0);b=c.getBindGroupLayout(b);W[a>>>0]=b;return a}
+function Ud(a,b){function c(e){var f=(u(),B)[e+8>>>2>>>0],h=(u(),B)[e+32>>>2>>>0],k=(u(),B)[e+36>>>2>>>0],m=0;ch(e,{327681:p=>{m=(u(),B)[p+8>>>2>>>0]}});f?(h=Xg(e+24),-1==h&&(h=void 0),f={buffer:Y(f),offset:Xg(e+16),size:h}):f=Y(h||k||m);return{binding:(u(),B)[e+4>>>2>>>0],resource:f}}a>>>=0;b>>>=0;b={label:Z(b+4),layout:Y((u(),B)[b+12>>>2>>>0]),entries:function(e,f){for(var h=[],k=0;k<e;++k)h.push(c(f+40*k));return h}((u(),B)[b+16>>>2>>>0],(u(),B)[b+20>>>2>>>0])};a=Y(a);var d=le(0);Yg(d,a.createBindGroup(b));
+return d}function Vd(a,b){a>>>=0;b>>>=0;var c;b&&(c={label:Z(b+4)});b=Y(a);a=oe(0);c=b.createCommandEncoder(c);W[a>>>0]=c;return a}function Wd(a,b){a>>>=0;b>>>=0;b={type:lh[(u(),A)[b+12>>>2>>>0]],count:(u(),B)[b+16>>>2>>>0]};var c=Y(a);a=qe(0);b=c.createQuerySet(b);W[a>>>0]=b;return a}
+function Xd(a,b){a=Y(a>>>0).adapterInfo;b>>>=0;(u(),B)[b+52>>>2>>>0]=a.subgroupMinSize;(u(),B)[b+56>>>2>>>0]=a.subgroupMaxSize;var c=a.vendor+a.architecture+a.device+a.description;var d=U(c)+1,e=ie(d);e&&T(c,e,d);c=e;d=U(a.vendor);dh(b+4,c,d);c+=d;d=U(a.architecture);dh(b+12,c,d);c+=d;d=U(a.device);dh(b+20,c,d);dh(b+28,c+d,U(a.description));(u(),A)[b+36>>>2>>>0]=2;a=a.isFallbackAdapter?3:4;(u(),A)[b+40>>>2>>>0]=a;(u(),B)[b+44>>>2>>>0]=0;(u(),B)[b+48>>>2>>>0]=0;return 1}
+var rh={"core-features-and-limits":1,"depth-clip-control":2,"depth32float-stencil8":3,"texture-compression-bc":4,"texture-compression-bc-sliced-3d":5,"texture-compression-etc2":6,"texture-compression-astc":7,"texture-compression-astc-sliced-3d":8,"timestamp-query":9,"indirect-first-instance":10,"shader-f16":11,"rg11b10ufloat-renderable":12,"bgra8unorm-storage":13,"float32-filterable":14,"float32-blendable":15,"clip-distances":16,"dual-source-blending":17,subgroups:18,"texture-formats-tier1":19,"texture-formats-tier2":20,
+"primitive-index":21,"texture-component-swizzle":22,"chromium-experimental-unorm16-texture-formats":327692,"chromium-experimental-multi-draw-indirect":327729};function Yd(a,b){b>>>=0;var c=Y(a>>>0);a=ie(4*c.features.size);var d=0,e=0;for(const f of c.features)c=rh[f],0<=c&&((u(),A)[a+d>>>2>>>0]=c,d+=4,e++);(u(),B)[b+4>>>2>>>0]=a;(u(),B)[b>>>2>>>0]=e}function Zd(a,b){gh(Y(a>>>0).limits,b>>>0);return 1}function $d(a,b){Y(a>>>0).pushErrorScope(hh[b])}
+function ae(a,b,c){b>>>=0;c>>>=0;a=Y(a>>>0);b=Array.from((u(),A).subarray(c>>>2>>>0,c+4*b>>>2>>>0),d=>Y(d));a.submit(b)}function be(a,b,c,d,e){c=O(c);d>>>=0;e>>>=0;a=Y(a>>>0);b=Y(b>>>0);d=(u(),x).subarray(d>>>0,d+e>>>0);a.writeBuffer(b,c,d,0,e)}n||Lf();n||(v=new WebAssembly.Memory({initial:256,maximum:65536,shared:!0}),wa());g.wasmBinary&&(sa=g.wasmBinary);g.stackSave=()=>K();g.stackRestore=a=>J(a);g.stackAlloc=a=>Je(a);
+g.setValue=function(a,b,c="i8"){c.endsWith("*")&&(c="*");switch(c){case "i1":(u(),w)[a>>>0]=b;break;case "i8":(u(),w)[a>>>0]=b;break;case "i16":(u(),Na)[a>>>1>>>0]=b;break;case "i32":(u(),A)[a>>>2>>>0]=b;break;case "i64":(u(),F)[a>>>3>>>0]=BigInt(b);break;case "float":(u(),Pa)[a>>>2>>>0]=b;break;case "double":(u(),E)[a>>>3>>>0]=b;break;case "*":(u(),B)[a>>>2>>>0]=b;break;default:Ta(`invalid type for setValue: ${c}`)}};
+g.getValue=function(a,b="i8"){b.endsWith("*")&&(b="*");switch(b){case "i1":return(u(),w)[a>>>0];case "i8":return(u(),w)[a>>>0];case "i16":return(u(),Na)[a>>>1>>>0];case "i32":return(u(),A)[a>>>2>>>0];case "i64":return(u(),F)[a>>>3>>>0];case "float":return(u(),Pa)[a>>>2>>>0];case "double":return(u(),E)[a>>>3>>>0];case "*":return(u(),B)[a>>>2>>>0];default:Ta(`invalid type for getValue: ${b}`)}};g.UTF8ToString=Zf;g.stringToUTF8=T;g.lengthBytesUTF8=U;
+var ug=[Dd,Kf,Vf,jb,kb,lb,mb,nb,ob,pb,qb,rb,sb,tb,ub,vb,gc,hc,ic,Kc,Lc,Nc,Oc,Pc,Qc],tg={1028716:(a,b,c,d,e)=>{if("undefined"==typeof g||!g.Vc)return 1;a=Zf(Number(a>>>0));a.startsWith("./")&&(a=a.substring(2));a=g.Vc.get(a);if(!a)return 2;b=Number(b>>>0);c=Number(c>>>0);d=Number(d>>>0);if(b+c>a.byteLength)return 3;try{const f=a.subarray(b,b+c);switch(e){case 0:(u(),x).set(f,d>>>0);break;case 1:g.bd?g.bd(d,f):g.pe(d,f);break;default:return 4}return 0}catch{return 4}},1029540:(a,b,c)=>{g.Td(a,(u(),
+x).subarray(b>>>0,b+c>>>0))},1029604:()=>g.ne(),1029646:a=>{g.kd(a)},1029683:()=>"undefined"!==typeof wasmOffsetConverter},fe,Ja,ge,he,H,ie,je,ke,le,me,ne,oe,pe,qe,re,se,te,ue,ve,we,xe,ye,ze,Ae,Ga,Ma,Be,Ce,De,Ee,Fe,Ge,I,He,Ie,J,Je,K,Ke,Le,Me,Ne,dynCall_vii,Oe,dynCall_v,Pe,Qe,Re,dynCall_iii,Se,Te,Ue,dynCall_vi,Ve,We,Xe,Ye,Ze,$e,af,bf,cf,df,ef,ff,gf,hf,jf,kf,lf,mf,nf,of,pf,qf,rf,sf,tf,uf,vf,wf,xf,yf,Za;function Yc(a,b,c,d){var e=K();try{return Ue(a,b,c,d)}catch(f){J(e);if(f!==f+0)throw f;I(1,0)}}
+function Xc(a,b,c){var d=K();try{return dynCall_iii(a,b,c)}catch(e){J(d);if(e!==e+0)throw e;I(1,0)}}function nd(a){var b=K();try{dynCall_v(a)}catch(c){J(b);if(c!==c+0)throw c;I(1,0)}}function Wc(a,b){var c=K();try{return Oe(a,b)}catch(d){J(c);if(d!==d+0)throw d;I(1,0)}}function pd(a,b,c){var d=K();try{dynCall_vii(a,b,c)}catch(e){J(d);if(e!==e+0)throw e;I(1,0)}}function od(a,b){var c=K();try{dynCall_vi(a,b)}catch(d){J(c);if(d!==d+0)throw d;I(1,0)}}
+function bd(a,b,c,d,e,f,h){var k=K();try{return Re(a,b,c,d,e,f,h)}catch(m){J(k);if(m!==m+0)throw m;I(1,0)}}function td(a,b,c,d,e,f){var h=K();try{Pe(a,b,c,d,e,f)}catch(k){J(h);if(k!==k+0)throw k;I(1,0)}}function rd(a,b,c,d){var e=K();try{Te(a,b,c,d)}catch(f){J(e);if(f!==f+0)throw f;I(1,0)}}function ud(a,b,c,d,e,f,h){var k=K();try{We(a,b,c,d,e,f,h)}catch(m){J(k);if(m!==m+0)throw m;I(1,0)}}function Ad(a,b,c,d,e,f,h){var k=K();try{Xe(a,b,c,d,e,f,h)}catch(m){J(k);if(m!==m+0)throw m;I(1,0)}}
+function zd(a,b,c,d,e,f,h,k){var m=K();try{ff(a,b,c,d,e,f,h,k)}catch(p){J(m);if(p!==p+0)throw p;I(1,0)}}function xd(a,b,c,d,e,f,h,k,m,p,C,r){var y=K();try{Ye(a,b,c,d,e,f,h,k,m,p,C,r)}catch(z){J(y);if(z!==z+0)throw z;I(1,0)}}function Zc(a,b,c,d,e){var f=K();try{return Ve(a,b,c,d,e)}catch(h){J(f);if(h!==h+0)throw h;I(1,0)}}function Bd(a,b,c,d,e,f){var h=K();try{gf(a,b,c,d,e,f)}catch(k){J(h);if(k!==k+0)throw k;I(1,0)}}
+function sd(a,b,c,d,e){var f=K();try{Qe(a,b,c,d,e)}catch(h){J(f);if(h!==h+0)throw h;I(1,0)}}function vd(a,b,c,d,e,f,h,k){var m=K();try{Se(a,b,c,d,e,f,h,k)}catch(p){J(m);if(p!==p+0)throw p;I(1,0)}}function Vc(a){var b=K();try{return hf(a)}catch(c){J(b);if(c!==c+0)throw c;I(1,0)}}function hd(a,b,c){var d=K();try{return jf(a,b,c)}catch(e){J(d);if(e!==e+0)throw e;I(1,0)}}function kd(a,b){var c=K();try{return uf(a,b)}catch(d){J(c);if(d!==d+0)throw d;I(1,0);return 0n}}
+function jd(a){var b=K();try{return Ze(a)}catch(c){J(b);if(c!==c+0)throw c;I(1,0);return 0n}}function gd(a,b,c,d){var e=K();try{return kf(a,b,c,d)}catch(f){J(e);if(f!==f+0)throw f;I(1,0)}}function fd(a,b,c,d,e){var f=K();try{return lf(a,b,c,d,e)}catch(h){J(f);if(h!==h+0)throw h;I(1,0)}}function ed(a,b,c,d,e,f){var h=K();try{return mf(a,b,c,d,e,f)}catch(k){J(h);if(k!==k+0)throw k;I(1,0)}}function ad(a,b,c,d,e,f){var h=K();try{return df(a,b,c,d,e,f)}catch(k){J(h);if(k!==k+0)throw k;I(1,0)}}
+function $c(a,b,c,d,e,f){var h=K();try{return nf(a,b,c,d,e,f)}catch(k){J(h);if(k!==k+0)throw k;I(1,0)}}function cd(a,b,c,d,e,f,h,k){var m=K();try{return ef(a,b,c,d,e,f,h,k)}catch(p){J(m);if(p!==p+0)throw p;I(1,0)}}function md(a,b,c,d,e){var f=K();try{return of(a,b,c,d,e)}catch(h){J(f);if(h!==h+0)throw h;I(1,0);return 0n}}function Uc(a,b,c,d){var e=K();try{return pf(a,b,c,d)}catch(f){J(e);if(f!==f+0)throw f;I(1,0)}}
+function Sc(a,b,c,d){var e=K();try{return qf(a,b,c,d)}catch(f){J(e);if(f!==f+0)throw f;I(1,0)}}function dd(a,b,c,d,e,f,h,k,m,p,C,r){var y=K();try{return rf(a,b,c,d,e,f,h,k,m,p,C,r)}catch(z){J(y);if(z!==z+0)throw z;I(1,0)}}function wd(a,b,c,d,e,f,h,k,m,p,C){var r=K();try{sf(a,b,c,d,e,f,h,k,m,p,C)}catch(y){J(r);if(y!==y+0)throw y;I(1,0)}}function yd(a,b,c,d,e,f,h,k,m,p,C,r,y,z,D,za){var yb=K();try{tf(a,b,c,d,e,f,h,k,m,p,C,r,y,z,D,za)}catch(Bb){J(yb);if(Bb!==Bb+0)throw Bb;I(1,0)}}
+function ld(a,b,c){var d=K();try{return af(a,b,c)}catch(e){J(d);if(e!==e+0)throw e;I(1,0);return 0n}}function Tc(a,b,c){var d=K();try{return $e(a,b,c)}catch(e){J(d);if(e!==e+0)throw e;I(1,0)}}function Rc(a,b,c){var d=K();try{return bf(a,b,c)}catch(e){J(d);if(e!==e+0)throw e;I(1,0)}}function qd(a,b,c,d){var e=K();try{cf(a,b,c,d)}catch(f){J(e);if(f!==f+0)throw f;I(1,0)}}
+function de(){var a=G;a=Object.assign({},a);var b=d=>e=>d(e)>>>0,c=d=>()=>d()>>>0;a.ac=b(a.ac);a.Dc=c(a.Dc);a.Fc=b(a.Fc);a.sd=(d=>(e,f)=>d(e,f)>>>0)(a.sd);a.xd=b(a.xd);a.yd=c(a.yd);a.Cd=b(a.Cd);return a}function Ea(){if(0<Cf)Df=Ea;else if(n)xa?.(g),Sa();else{for(var a=Bf;0<a.length;)a.shift()(g);0<Cf?Df=Ea:(g.calledRun=!0,ua||(Sa(),xa?.(g)))}}var G;n||(G=await (Da()),Ea());g.PTR_SIZE=4;
+g.webgpuInit=a=>{const b=new WeakMap;let c=1,d=void 0,e=void 0;g.webgpuRegisterDevice=k=>{if(void 0!==e)throw Error("another WebGPU EP inference session is being created.");if(k){var m=b.get(k);if(!m){m=ke(0);const p=bh(k,m);m=[c++,m,p];b.set(k,m)}d=k;e=m[0];return m}d=void 0;e=0};const f=new Map;g.webgpuOnCreateSession=k=>{if(void 0!==e){var m=e;e=void 0;if(k){const p=ge(m);f.set(k,p);0===m&&a(d??Y(p))}d=void 0}};g.webgpuOnReleaseSession=k=>{f.delete(k)};const h=Symbol("gpuBufferMetadata");g.webgpuRegisterBuffer=
+(k,m,p)=>{if(p)return k[h]=[p,NaN],p;if(p=k[h])return p[1]++,p[0];m=f.get(m);if(void 0===m)throw Error("Invalid session handle passed to webgpuRegisterBuffer");m=ah(k,m);k[h]=[m,1];return m};g.webgpuUnregisterBuffer=k=>{const m=k[h];if(!m)throw Error("Buffer is not registered");m[1]--;0===m[1]&&(je(m[0]),delete k[h])};g.webgpuGetBuffer=k=>Y(k);g.webgpuCreateDownloader=(k,m,p)=>{p=f.get(p);if(void 0===p)throw Error("Invalid session handle passed to webgpuRegisterBuffer");const C=Y(p),r=16*Math.ceil(Number(m)/
+16);return async()=>{const y=C.createBuffer({size:r,usage:9});try{const z=C.createCommandEncoder();z.copyBufferToBuffer(k,0,y,0,r);C.queue.submit([z.finish()]);await y.mapAsync(GPUMapMode.READ);return y.getMappedRange().slice(0,m)}finally{y.destroy()}}};g.bd=(k,m)=>{var p=m.buffer;const C=m.byteOffset,r=m.byteLength;m=16*Math.ceil(Number(r)/16);k=Y(k);if(!d){var y=ge(e);d=Y(y)}y=d.createBuffer({mappedAtCreation:!0,size:m,usage:6});const z=y.getMappedRange();(new Uint8Array(z)).set(new Uint8Array(p,
+C,r));y.unmap();p=d.createCommandEncoder();p.copyBufferToBuffer(y,0,k,0,m);d.queue.submit([p.finish()]);y.destroy()}};
+g.webnnInit=a=>{const b=a[0];[g.ne,g.kd,g.webnnEnsureTensor,g.Td,g.webnnDownloadTensor,g.me,g.webnnEnableTraceEvent]=a.slice(1);g.webnnReleaseTensorId=g.kd;g.webnnUploadTensor=g.Td;g.webnnRegisterMLContext=g.me;g.webnnOnRunStart=c=>b.onRunStart(c);g.webnnOnRunEnd=b.onRunEnd.bind(b);g.webnnOnReleaseSession=c=>{b.onReleaseSession(c)};g.webnnCreateMLTensorDownloader=(c,d)=>b.createMLTensorDownloader(c,d);g.webnnRegisterMLTensor=(c,d,e,f)=>b.registerMLTensor(c,d,e,f);g.webnnCreateMLContext=c=>b.createMLContext(c);
+g.webnnRegisterMLConstant=(c,d,e,f,h,k)=>b.registerMLConstant(c,d,e,f,h,g.Vc,k);g.webnnRegisterGraphInput=b.registerGraphInput.bind(b);g.webnnIsGraphInput=b.isGraphInput.bind(b);g.webnnRegisterGraphOutput=b.registerGraphOutput.bind(b);g.webnnIsGraphOutput=b.isGraphOutput.bind(b);g.webnnCreateTemporaryTensor=b.createTemporaryTensor.bind(b);g.webnnIsGraphInputOutputTypeSupported=b.isGraphInputOutputTypeSupported.bind(b)};Ra?moduleRtn=g:moduleRtn=new Promise((a,b)=>{xa=a;ya=b});
+;return moduleRtn}export default ortWasmThreaded;var isPthread=globalThis.self?.name?.startsWith("em-pthread");var isNode=globalThis.process?.versions?.node&&globalThis.process?.type!="renderer";if(isNode)isPthread=(await import("worker_threads")).workerData==="em-pthread";isPthread&&ortWasmThreaded();

runtime/vendor/ort-wasm-simd-threaded.asyncify.wasm

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7e83cd6cee77e478bc96a7e91b198144fb5e4126287daf1f9b54bb195ebcd55a
+size 24254953

tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c7dc553ba83607a7d3cde4782e4055fcd15cb228f8f1cdc3fc149b1094580592
+size 10548223

tokenizer_config.json

@@ -0,0 +1,18 @@
+{
+  "add_prefix_space": null,
+  "backend": "tokenizers",
+  "bos_token": "<s>",
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "</s>",
+  "is_local": true,
+  "legacy": true,
+  "local_files_only": true,
+  "model_max_length": 131072,
+  "pad_token": "</s>",
+  "sp_model_kwargs": {},
+  "spaces_between_special_tokens": false,
+  "tokenizer_class": "TokenizersBackend",
+  "unk_token": "<unk>",
+  "use_default_system_prompt": false,
+  "chat_template": "{{- bos_token }}{%- if tools %}\n    {%- set tool_definitions %}\n        {{- \"# Tools\\n\\nYou are provided with function signatures within <tools></tools> XML tags:\\n<tools>\" }}\n        {%- for tool in tools %}\n            {{- \"\\n\" }}\n            {{- tool | tojson(ensure_ascii=False) }}\n        {%- endfor %}\n        {{- '\\n</tools>\\n\\nTool usage guidelines:\\n- You may call zero or more functions. If no function calls are needed, just answer normally and do not include any <function ... </function>.\\n- When calling a function, return an XML object within <function ... </function> using:\\n<function name=\"function-name\"><param name=\"param-name\">param-value</param></function>\\n- param-value may be multi-line. If it contains <, & or newline characters, wrap it in a CDATA block: <param name=\"param-name\"><![CDATA[...multi-line value...]]></param>' }}\n    {%- endset %}\n    \n    {{- '<|im_start|>system\\n' }}\n    {%- if messages[0].role == 'system' %}\n        {%- if '<tool_def_sep>' in messages[0].content %}\n            {{- messages[0].content.replace('<tool_def_sep>', tool_definitions) }}\n        {%- else %}\n            {{- messages[0].content + '\\n\\n' + tool_definitions }}\n        {%- endif %}\n    {%- else %}\n        {{- tool_definitions.lstrip() }}\n    {%- endif %}\n    {{- '<|im_end|>\\n' }}\n{%- else %}\n    {%- if messages[0].role == 'system' %}\n        {{- '<|im_start|>system\\n' + messages[0].content + '<|im_end|>\\n' }}\n    {%- endif %}\n{%- endif %}\n{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %}\n{%- for message in messages[::-1] %}\n    {%- set index = (messages|length - 1) - loop.index0 %}\n    {%- if ns.multi_step_tool and message.role == \"user\" and message.content is string and not(message.content.startswith('<tool_response>') and message.content.endswith('</tool_response>')) %}\n        {%- set ns.multi_step_tool = false %}\n        {%- set ns.last_query_index = index %}\n    {%- endif %}\n{%- endfor %}\n{%- for message in messages %}\n    {%- if message.content is string %}\n        {%- set content = message.content %}\n    {%- else %}\n        {%- set content = '' %}\n    {%- endif %}\n    {%- if (message.role == \"user\") or (message.role == \"system\" and not loop.first) %}\n        {{- '<|im_start|>' + message.role + '\\n' + content + '<|im_end|>' + '\\n' }}\n    {%- elif message.role == \"assistant\" %}\n        {%- set reasoning_content = '' %}\n        {%- if message.reasoning_content is string %}\n            {%- set reasoning_content = message.reasoning_content %}\n        {%- else %}\n            {%- if '</think>' in content %}\n                {%- set reasoning_content = content.split('</think>')[0].rstrip('\\n').split('<think>')[-1].lstrip('\\n') %}\n                {%- set content = content.split('</think>')[-1].lstrip('\\n') %}\n            {%- endif %}\n        {%- endif %}\n        \n        {%- if message.tool_calls %}\n            {%- set content_parts = content.split('<tool_sep>') %}\n            {%- set processed_content = content_parts[0] %}\n            {%- set tool_calls_count = message.tool_calls|length %}\n            {%- set tool_sep_count = content_parts|length - 1 %}\n            \n            {%- for i in range(1, content_parts|length) %}\n                {%- set tool_index = i - 1 %}\n                {%- if tool_index < tool_calls_count %}\n                    {%- set tool_call = message.tool_calls[tool_index] %}\n                    {%- if tool_call.function %}\n                        {%- set tool_call = tool_call.function %}\n                    {%- endif %}\n                    {%- set single_tool_xml %}\n                        {{- '<function name=\"' ~ tool_call.name ~ '\">' }}\n                        {%- if tool_call.arguments %}\n                            {%- set args_dict = tool_call.arguments %}\n                            {%- for param_name, param_value in args_dict.items() %}\n                                {{- '<param name=\"' ~ param_name ~ '\">' }}\n                                {%- if param_value is string and ('<' in param_value or '&' in param_value or '\\n' in param_value) %}\n                                    {{- '<![CDATA[' + param_value + ']]>' }}\n                                {%- else %}\n                                    {{- param_value }}\n                                {%- endif %}\n                                {{- '</param>' }}\n                            {%- endfor %}\n                        {%- endif %}\n                        {{- '</function>' }}\n                    {%- endset %}\n                    {%- set processed_content = processed_content + single_tool_xml + content_parts[i] %}\n                {%- else %}\n                    {%- set processed_content = processed_content + content_parts[i] %}\n                {%- endif %}\n            {%- endfor %}\n            \n            {%- if tool_calls_count > tool_sep_count %}\n                {%- for remaining_index in range(tool_sep_count, tool_calls_count) %}\n                    {%- set tool_call = message.tool_calls[remaining_index] %}\n                    {%- if tool_call.function %}\n                        {%- set tool_call = tool_call.function %}\n                    {%- endif %}\n                    {%- set remaining_tool_xml %}\n                        {{- '<function name=\"' ~ tool_call.name ~ '\">' }}\n                        {%- if tool_call.arguments %}\n                            {%- set args_dict = tool_call.arguments %}\n                            {%- for param_name, param_value in args_dict.items() %}\n                                {{- '<param name=\"' ~ param_name ~ '\">' }}\n                                {%- if param_value is string and ('<' in param_value or '&' in param_value or '\\n' in param_value) %}\n                                    {{- '<![CDATA[' + param_value + ']]>' }}\n                                {%- else %}\n                                    {{- param_value }}\n                                {%- endif %}\n                                {{- '</param>' }}\n                            {%- endfor %}\n                        {%- endif %}\n                        {{- '</function>' }}\n                    {%- endset %}\n                    {%- set processed_content = processed_content + remaining_tool_xml %}\n                {%- endfor %}\n            {%- endif %}\n            \n            {%- set content = processed_content %}\n        {%- endif %}\n        \n        {%- if reasoning_content %}\n            {{- '<|im_start|>' + message.role + '\\n<think>\\n' + reasoning_content.strip('\\n') + '\\n</think>\\n\\n' + content.lstrip('\\n') }}\n        {%- elif '<think>' not in content and '</think>' not in content %}\n            {{- '<|im_start|>' + message.role + '\\n<think>\\n\\n</think>\\n\\n' + content.lstrip('\\n') }}\n        {%- else %}\n            {{- '<|im_start|>' + message.role + '\\n' + content }}\n        {%- endif %}\n        \n        {%- if message.tool_calls and not has_tool_sep %}\n            {%- for tool_call in message.tool_calls %}\n                {%- if (loop.first and content) or (not loop.first) %}\n                    {{- '\\n' }}\n                {%- endif %}\n                {%- if tool_call.function %}\n                    {%- set tool_call = tool_call.function %}\n                {%- endif %}\n                {{- '<function name=\"' ~ tool_call.name ~ '\">' }}\n                {%- if tool_call.arguments %}\n                    {%- set args_dict = tool_call.arguments %}\n                    {%- for param_name, param_value in args_dict.items() %}\n                        {{- '<param name=\"' ~ param_name ~ '\">' }}\n                        {%- if param_value is string and ('<' in param_value or '&' in param_value or '\\n' in param_value) %}\n                            {{- '<![CDATA[' + param_value + ']]>' }}\n                        {%- else %}\n                            {{- param_value }}\n                        {%- endif %}\n                        {{- '</param>' }}\n                    {%- endfor %}\n                {%- endif %}\n                {{- '</function>' }}\n            {%- endfor %}\n        {%- endif %}\n        {{- '<|im_end|>\\n' }}\n    {%- elif message.role == \"tool\" %}\n        {%- if loop.first or (messages[loop.index0 - 1].role != \"tool\") %}\n            {{- '<|im_start|>user' }}\n        {%- endif %}\n        {{- '\\n<tool_response>\\n' }}\n        {%- if message.content is string %}\n            {{- content }}\n        {%- else %}\n            {{- message.content | tojson(ensure_ascii=False) }}\n        {%- endif %}\n        {{- '\\n</tool_response>' }}\n        {%- if loop.last or (messages[loop.index0 + 1].role != \"tool\") %}\n            {{- '<|im_end|>\\n' }}\n        {%- endif %}\n    {%- endif %}\n{%- endfor %}\n{%- if add_generation_prompt %}\n    {{- '<|im_start|>assistant\\n' }}\n    {%- if enable_thinking is defined %}\n        {%- if enable_thinking is false %}\n            {{- '<think>\\n\\n</think>\\n\\n' }}\n        {%- elif enable_thinking is true %}\n            {{- '<think>\\n' }}\n        {%- endif %}\n    {%- endif %}\n{%- endif %}\n"
+}

validation/cold-cache-results.json

@@ -0,0 +1,29 @@
+{
+  "status": "passed",
+  "modelNetworkDisabled": true,
+  "nativeToolCallExact": true,
+  "coldBrowserRestart": true,
+  "cacheBytes": 1879921408,
+  "browser": "150.0.7871.187",
+  "cases": [
+    {
+      "case": "single_address",
+      "contentSha256": "6fb7d867dc3ffc68a48c3d8ba62326085e54207791b1fe596ed1ccefe57520ce",
+      "unchanged": true
+    },
+    {
+      "case": "escaped_address",
+      "contentSha256": "bbca493756a904976f235188b871396fe327e0257118ca15b9a428b06fb30e52",
+      "unchanged": true
+    },
+    {
+      "case": "typed_labels",
+      "contentSha256": "400631740d1f4d911f6fb52e748a92e2700e4cbda20e7aae7c2a68f39530dcbb",
+      "unchanged": true
+    }
+  ],
+  "harnessSha256": "140c191d0f0b9cd50a6376deb2ca8e0042340a3f964915e192cff91f2fbef652",
+  "readySha256": "659375dbc84327f36a0de545aa1f769771f386a01e4a4d083707f9261530f395",
+  "eventsSha256": "6ed824b7f684f4f154b08805b2a191bfb66d0eccd7a91c54bfdb43874faa91d7",
+  "time": 1789231468.5665188
+}

validation/context-results.json

@@ -0,0 +1,31 @@
+{
+  "status": "passed",
+  "contextWindowExercised": 16384,
+  "results": [
+    {
+      "inputTokens": 4088,
+      "generatedTokens": 8,
+      "finite": true,
+      "seconds": 1.199800000190735
+    },
+    {
+      "inputTokens": 8184,
+      "generatedTokens": 8,
+      "finite": true,
+      "seconds": 2.257800000190735
+    },
+    {
+      "inputTokens": 16376,
+      "generatedTokens": 8,
+      "finite": true,
+      "seconds": 5.950199999809265
+    },
+    {
+      "inputTokens": 16383,
+      "generatedTokens": 1,
+      "finite": true,
+      "seconds": 5.6705
+    }
+  ],
+  "implementationSha256": "6502ce8d72aa9f9a68d9fa8aa646543d1d6bcfa089db92658e4da3af3c2abd80"
+}

validation/numerical-results.json

@@ -0,0 +1,319 @@
+{
+  "passed": true,
+  "checks": [
+    {
+      "case": "single_address",
+      "step": 0,
+      "sourceBf16ToFp16": {
+        "maxAbs": 0.248046875,
+        "relativeRms": 0.012782927668845466,
+        "cosine": 0.9999188460342593,
+        "top1Equal": true,
+        "finite": true
+      },
+      "fp16ToGptq": {
+        "maxAbs": 2.92236328125,
+        "relativeRms": 0.1725033061543679,
+        "cosine": 0.9851563643330277,
+        "top1Equal": true,
+        "finite": true
+      },
+      "gptqToWebgpu": {
+        "maxAbs": 0.0673828125,
+        "relativeRms": 0.0042797916585819926,
+        "cosine": 0.9999915840946518,
+        "top1Equal": true,
+        "finite": true
+      },
+      "passed": true
+    },
+    {
+      "case": "single_address",
+      "step": 1,
+      "sourceBf16ToFp16": {
+        "maxAbs": 0.392578125,
+        "relativeRms": 0.03175030043037405,
+        "cosine": 0.9995014526875671,
+        "top1Equal": true,
+        "finite": true
+      },
+      "fp16ToGptq": {
+        "maxAbs": 5.8984375,
+        "relativeRms": 0.4321884810039682,
+        "cosine": 0.9178090500009005,
+        "top1Equal": true,
+        "finite": true
+      },
+      "gptqToWebgpu": {
+        "maxAbs": 0.1185302734375,
+        "relativeRms": 0.009224104859662774,
+        "cosine": 0.9999598279641384,
+        "top1Equal": true,
+        "finite": true
+      },
+      "passed": true
+    },
+    {
+      "case": "single_address",
+      "step": 2,
+      "sourceBf16ToFp16": {
+        "maxAbs": 0.40625,
+        "relativeRms": 0.024433671533829995,
+        "cosine": 0.9998189972088237,
+        "top1Equal": true,
+        "finite": true
+      },
+      "fp16ToGptq": {
+        "maxAbs": 4.21875,
+        "relativeRms": 0.15488227828082832,
+        "cosine": 0.9880322921705068,
+        "top1Equal": true,
+        "finite": true
+      },
+      "gptqToWebgpu": {
+        "maxAbs": 0.125,
+        "relativeRms": 0.00558969882051299,
+        "cosine": 0.9999846162524721,
+        "top1Equal": true,
+        "finite": true
+      },
+      "passed": true
+    },
+    {
+      "case": "single_address",
+      "step": 3,
+      "sourceBf16ToFp16": {
+        "maxAbs": 0.244140625,
+        "relativeRms": 0.02230636952290329,
+        "cosine": 0.9997514739004472,
+        "top1Equal": true,
+        "finite": true
+      },
+      "fp16ToGptq": {
+        "maxAbs": 2.0703125,
+        "relativeRms": 0.15789749529090216,
+        "cosine": 0.9876037120121298,
+        "top1Equal": true,
+        "finite": true
+      },
+      "gptqToWebgpu": {
+        "maxAbs": 0.0888671875,
+        "relativeRms": 0.00605211109920661,
+        "cosine": 0.9999817012220191,
+        "top1Equal": true,
+        "finite": true
+      },
+      "passed": true
+    },
+    {
+      "case": "typed_labels",
+      "step": 0,
+      "sourceBf16ToFp16": {
+        "maxAbs": 0.38671875,
+        "relativeRms": 0.025063363075193648,
+        "cosine": 0.9997845808098521,
+        "top1Equal": true,
+        "finite": true
+      },
+      "fp16ToGptq": {
+        "maxAbs": 2.6171875,
+        "relativeRms": 0.1662042144350609,
+        "cosine": 0.9868052467412282,
+        "top1Equal": true,
+        "finite": true
+      },
+      "gptqToWebgpu": {
+        "maxAbs": 0.078125,
+        "relativeRms": 0.005452968305617882,
+        "cosine": 0.9999875200694265,
+        "top1Equal": true,
+        "finite": true
+      },
+      "passed": true
+    },
+    {
+      "case": "typed_labels",
+      "step": 1,
+      "sourceBf16ToFp16": {
+        "maxAbs": 0.380859375,
+        "relativeRms": 0.0250109210315334,
+        "cosine": 0.9997064286834567,
+        "top1Equal": true,
+        "finite": true
+      },
+      "fp16ToGptq": {
+        "maxAbs": 7.640625,
+        "relativeRms": 0.57221657649197,
+        "cosine": 0.8201217343475685,
+        "top1Equal": true,
+        "finite": true
+      },
+      "gptqToWebgpu": {
+        "maxAbs": 0.212890625,
+        "relativeRms": 0.018333812515897996,
+        "cosine": 0.999833960131897,
+        "top1Equal": true,
+        "finite": true
+      },
+      "passed": true
+    },
+    {
+      "case": "typed_labels",
+      "step": 2,
+      "sourceBf16ToFp16": {
+        "maxAbs": 0.345703125,
+        "relativeRms": 0.018745048201074564,
+        "cosine": 0.9998726263349046,
+        "top1Equal": true,
+        "finite": true
+      },
+      "fp16ToGptq": {
+        "maxAbs": 4.439453125,
+        "relativeRms": 0.19829943940799244,
+        "cosine": 0.9824647962089508,
+        "top1Equal": true,
+        "finite": true
+      },
+      "gptqToWebgpu": {
+        "maxAbs": 0.1796875,
+        "relativeRms": 0.006915722281827882,
+        "cosine": 0.9999793827494786,
+        "top1Equal": true,
+        "finite": true
+      },
+      "passed": true
+    },
+    {
+      "case": "typed_labels",
+      "step": 3,
+      "sourceBf16ToFp16": {
+        "maxAbs": 0.234375,
+        "relativeRms": 0.018754406808742356,
+        "cosine": 0.999827896719525,
+        "top1Equal": true,
+        "finite": true
+      },
+      "fp16ToGptq": {
+        "maxAbs": 2.617431640625,
+        "relativeRms": 0.186232702205544,
+        "cosine": 0.9827491247292427,
+        "top1Equal": true,
+        "finite": true
+      },
+      "gptqToWebgpu": {
+        "maxAbs": 0.076171875,
+        "relativeRms": 0.005799131539776698,
+        "cosine": 0.9999832046335031,
+        "top1Equal": true,
+        "finite": true
+      },
+      "passed": true
+    },
+    {
+      "case": "tool_history",
+      "step": 0,
+      "sourceBf16ToFp16": {
+        "maxAbs": 0.1943359375,
+        "relativeRms": 0.011942814015739078,
+        "cosine": 0.9999351512834989,
+        "top1Equal": true,
+        "finite": true
+      },
+      "fp16ToGptq": {
+        "maxAbs": 3.724609375,
+        "relativeRms": 0.1542023887030577,
+        "cosine": 0.9880457221982332,
+        "top1Equal": true,
+        "finite": true
+      },
+      "gptqToWebgpu": {
+        "maxAbs": 0.07421875,
+        "relativeRms": 0.004467858699488606,
+        "cosine": 0.9999902288828103,
+        "top1Equal": true,
+        "finite": true
+      },
+      "passed": true
+    },
+    {
+      "case": "tool_history",
+      "step": 1,
+      "sourceBf16ToFp16": {
+        "maxAbs": 0.55859375,
+        "relativeRms": 0.028931119415106666,
+        "cosine": 0.9995831520949008,
+        "top1Equal": true,
+        "finite": true
+      },
+      "fp16ToGptq": {
+        "maxAbs": 5.9765625,
+        "relativeRms": 0.3487054531078975,
+        "cosine": 0.9377851831391082,
+        "top1Equal": true,
+        "finite": true
+      },
+      "gptqToWebgpu": {
+        "maxAbs": 0.14453125,
+        "relativeRms": 0.01074293845406932,
+        "cosine": 0.9999440250098686,
+        "top1Equal": true,
+        "finite": true
+      },
+      "passed": true
+    },
+    {
+      "case": "tool_history",
+      "step": 2,
+      "sourceBf16ToFp16": {
+        "maxAbs": 0.3828125,
+        "relativeRms": 0.016834366518147053,
+        "cosine": 0.9998583938821983,
+        "top1Equal": true,
+        "finite": true
+      },
+      "fp16ToGptq": {
+        "maxAbs": 5.638671875,
+        "relativeRms": 0.3736643910497181,
+        "cosine": 0.9318102942626478,
+        "top1Equal": true,
+        "finite": true
+      },
+      "gptqToWebgpu": {
+        "maxAbs": 0.1328125,
+        "relativeRms": 0.007678886224809575,
+        "cosine": 0.9999712093288873,
+        "top1Equal": true,
+        "finite": true
+      },
+      "passed": true
+    },
+    {
+      "case": "tool_history",
+      "step": 3,
+      "sourceBf16ToFp16": {
+        "maxAbs": 0.328125,
+        "relativeRms": 0.030876288162470202,
+        "cosine": 0.9995263219302111,
+        "top1Equal": true,
+        "finite": true
+      },
+      "fp16ToGptq": {
+        "maxAbs": 2.5712890625,
+        "relativeRms": 0.2003064180768053,
+        "cosine": 0.9805788883889465,
+        "top1Equal": true,
+        "finite": true
+      },
+      "gptqToWebgpu": {
+        "maxAbs": 0.09375,
+        "relativeRms": 0.006090321309410876,
+        "cosine": 0.9999814728684856,
+        "top1Equal": true,
+        "finite": true
+      },
+      "passed": true
+    }
+  ],
+  "packagedProofSha256": "dc91e19a96db79d51d77c15c1e03f755249021ae0fbf3403e4606ed877a664a1",
+  "uploadAllowed": false
+}

validation/parser-results.json

@@ -0,0 +1,92 @@
+{
+  "responseCount": 194,
+  "packageParserSha256": "7a33bbcd31cc3910a169e735541c4d5189f85480237577f262de3154ce91f12d",
+  "optionalHelperSha256": "0f1bf7265771ec5cf73147c299c52490086579bb2d2c9885cbddda7e067322e3",
+  "bundledMatches": 162,
+  "bundledMismatchCount": 32,
+  "optionalHelperMatches": 194,
+  "optionalHelperMismatchCount": 0,
+  "optionalHelperAllowlistFailures": 0,
+  "smoke": [
+    {
+      "name": "single_address",
+      "sameTypedArguments": true,
+      "bundled": {
+        "calls": [
+          {
+            "name": "open_address",
+            "args": {
+              "address": "https://example.net/guide"
+            }
+          }
+        ]
+      },
+      "helper": {
+        "calls": [
+          {
+            "name": "open_address",
+            "args": {
+              "address": "https://example.net/guide"
+            }
+          }
+        ]
+      }
+    },
+    {
+      "name": "escaped_address",
+      "sameTypedArguments": true,
+      "bundled": {
+        "calls": [
+          {
+            "name": "open_address",
+            "args": {
+              "address": "https://example.net/find?name=blue&sort=recent"
+            }
+          }
+        ]
+      },
+      "helper": {
+        "calls": [
+          {
+            "name": "open_address",
+            "args": {
+              "address": "https://example.net/find?name=blue&sort=recent"
+            }
+          }
+        ]
+      }
+    },
+    {
+      "name": "typed_labels",
+      "sameTypedArguments": false,
+      "bundled": {
+        "calls": [
+          {
+            "name": "save_labels",
+            "args": {
+              "labels": "['green', 'amber']",
+              "enabled": "False"
+            }
+          }
+        ]
+      },
+      "helper": {
+        "calls": [
+          {
+            "name": "save_labels",
+            "args": {
+              "labels": [
+                "green",
+                "amber"
+              ],
+              "enabled": false
+            }
+          }
+        ]
+      }
+    }
+  ],
+  "originalAuditSha256": "14e167d6a11fb7b87b93dbfcd1d94585a4ab79479bb2e058fa9ec5d5ebfe3030",
+  "optionalHelperAutomaticallyIntegrated": false,
+  "noToolsExecuted": true
+}