@alan-ai-hq/agent-manager-darwin-arm64 0.1.175 → 0.1.176
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/alan-agent.cjs +1067 -676
- package/alan-holder.cjs +274 -62
- package/package.json +1 -1
package/alan-agent.cjs
CHANGED
|
@@ -24761,8 +24761,8 @@ function hasExtension(name, extensions) {
|
|
|
24761
24761
|
return ext.length > 0 && extensions.includes(ext);
|
|
24762
24762
|
}
|
|
24763
24763
|
function candidates(base, extensions) {
|
|
24764
|
-
const
|
|
24765
|
-
return
|
|
24764
|
+
const extension2 = import_node_path18.win32.extname(base).toLowerCase();
|
|
24765
|
+
return extension2 === ".exe" || extension2 === ".com" || hasExtension(base, extensions) ? [base] : extensions.map((ext) => `${base}${ext}`);
|
|
24766
24766
|
}
|
|
24767
24767
|
function resolveWindowsCommand(command, env, files) {
|
|
24768
24768
|
const extensions = (windowsEnvValue(env, "PATHEXT") ?? DEFAULT_PATHEXT).split(";").map((ext) => ext.trim().toLowerCase()).filter((ext) => LAUNCHABLE_EXTENSIONS.has(ext));
|
|
@@ -27824,7 +27824,11 @@ var init_models = __esm({
|
|
|
27824
27824
|
sortOrder: 10,
|
|
27825
27825
|
upstreamModelId: "deepseek/deepseek-v4.1-flash-1017",
|
|
27826
27826
|
contextWindow: 1048576,
|
|
27827
|
-
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS
|
|
27827
|
+
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS,
|
|
27828
|
+
inputPriceMicroUsdPerMtok: 15e4,
|
|
27829
|
+
outputPriceMicroUsdPerMtok: 6e5,
|
|
27830
|
+
cacheReadPriceMicroUsdPerMtok: 3e3,
|
|
27831
|
+
routing: { tier: "workhorse", priority: 10, strengths: ["speed", "cost", "general"] }
|
|
27828
27832
|
},
|
|
27829
27833
|
{
|
|
27830
27834
|
id: "deepseek/deepseek-v4-pro",
|
|
@@ -27835,7 +27839,10 @@ var init_models = __esm({
|
|
|
27835
27839
|
sortOrder: 20,
|
|
27836
27840
|
upstreamModelId: "deepseek/deepseek-v4-pro",
|
|
27837
27841
|
contextWindow: 1048576,
|
|
27838
|
-
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS
|
|
27842
|
+
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS,
|
|
27843
|
+
inputPriceMicroUsdPerMtok: 816234,
|
|
27844
|
+
outputPriceMicroUsdPerMtok: 1632468,
|
|
27845
|
+
cacheReadPriceMicroUsdPerMtok: 68020
|
|
27839
27846
|
},
|
|
27840
27847
|
{
|
|
27841
27848
|
id: "particle-ai/particle-1",
|
|
@@ -27846,7 +27853,10 @@ var init_models = __esm({
|
|
|
27846
27853
|
sortOrder: 25,
|
|
27847
27854
|
upstreamModelId: "particle-ai/particle-1",
|
|
27848
27855
|
contextWindow: 1048576,
|
|
27849
|
-
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS
|
|
27856
|
+
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS,
|
|
27857
|
+
inputPriceMicroUsdPerMtok: 25e4,
|
|
27858
|
+
outputPriceMicroUsdPerMtok: 1e6,
|
|
27859
|
+
cacheReadPriceMicroUsdPerMtok: 3e3
|
|
27850
27860
|
},
|
|
27851
27861
|
{
|
|
27852
27862
|
id: "z-ai/glm-5.3",
|
|
@@ -27857,7 +27867,15 @@ var init_models = __esm({
|
|
|
27857
27867
|
sortOrder: 30,
|
|
27858
27868
|
upstreamModelId: "z-ai/glm-5.3",
|
|
27859
27869
|
contextWindow: 1048576,
|
|
27860
|
-
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS
|
|
27870
|
+
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS,
|
|
27871
|
+
inputPriceMicroUsdPerMtok: 8e4,
|
|
27872
|
+
outputPriceMicroUsdPerMtok: 36e5,
|
|
27873
|
+
cacheReadPriceMicroUsdPerMtok: 76e3,
|
|
27874
|
+
routing: {
|
|
27875
|
+
tier: "strong",
|
|
27876
|
+
priority: 20,
|
|
27877
|
+
strengths: ["architecture", "refactoring", "debugging"]
|
|
27878
|
+
}
|
|
27861
27879
|
},
|
|
27862
27880
|
{
|
|
27863
27881
|
id: "z-ai/glm-5.3-flash",
|
|
@@ -27868,7 +27886,39 @@ var init_models = __esm({
|
|
|
27868
27886
|
sortOrder: 40,
|
|
27869
27887
|
upstreamModelId: "z-ai/glm-5.3-flash",
|
|
27870
27888
|
contextWindow: 1048576,
|
|
27871
|
-
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS
|
|
27889
|
+
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS,
|
|
27890
|
+
inputPriceMicroUsdPerMtok: 15e4,
|
|
27891
|
+
outputPriceMicroUsdPerMtok: 5e5,
|
|
27892
|
+
cacheReadPriceMicroUsdPerMtok: 3e4,
|
|
27893
|
+
routing: { tier: "workhorse", priority: 20, strengths: ["ui_design", "speed"] }
|
|
27894
|
+
},
|
|
27895
|
+
{
|
|
27896
|
+
id: "z-ai/glm-5.3-flashx",
|
|
27897
|
+
name: "GLM 5.3 FlashX",
|
|
27898
|
+
description: "Mid-tier multimodal GLM between Flash and Prime",
|
|
27899
|
+
enabled: true,
|
|
27900
|
+
isDefault: false,
|
|
27901
|
+
sortOrder: 50,
|
|
27902
|
+
upstreamModelId: "z-ai/glm-5.3-flashx",
|
|
27903
|
+
contextWindow: 1048576,
|
|
27904
|
+
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS,
|
|
27905
|
+
inputPriceMicroUsdPerMtok: 37e4,
|
|
27906
|
+
outputPriceMicroUsdPerMtok: 125e4,
|
|
27907
|
+
cacheReadPriceMicroUsdPerMtok: 9e4
|
|
27908
|
+
},
|
|
27909
|
+
{
|
|
27910
|
+
id: "z-ai/glm-5.3-prime",
|
|
27911
|
+
name: "GLM 5.3 Prime",
|
|
27912
|
+
description: "Z.ai's premium GLM tier for demanding work",
|
|
27913
|
+
enabled: true,
|
|
27914
|
+
isDefault: false,
|
|
27915
|
+
sortOrder: 60,
|
|
27916
|
+
upstreamModelId: "z-ai/glm-5.3-prime",
|
|
27917
|
+
contextWindow: 1e6,
|
|
27918
|
+
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS,
|
|
27919
|
+
inputPriceMicroUsdPerMtok: 28e5,
|
|
27920
|
+
outputPriceMicroUsdPerMtok: 88e5,
|
|
27921
|
+
cacheReadPriceMicroUsdPerMtok: 56e4
|
|
27872
27922
|
},
|
|
27873
27923
|
{
|
|
27874
27924
|
id: "qwen/qwen3.8-27b",
|
|
@@ -27876,10 +27926,27 @@ var init_models = __esm({
|
|
|
27876
27926
|
description: "Qwen3.8 open-weight coding and agentic work",
|
|
27877
27927
|
enabled: true,
|
|
27878
27928
|
isDefault: false,
|
|
27879
|
-
sortOrder:
|
|
27929
|
+
sortOrder: 70,
|
|
27880
27930
|
upstreamModelId: "qwen/qwen3.8-27b",
|
|
27881
27931
|
contextWindow: 1e6,
|
|
27882
|
-
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS
|
|
27932
|
+
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS,
|
|
27933
|
+
inputPriceMicroUsdPerMtok: 15e4,
|
|
27934
|
+
outputPriceMicroUsdPerMtok: 1875e3,
|
|
27935
|
+
cacheReadPriceMicroUsdPerMtok: 37500
|
|
27936
|
+
},
|
|
27937
|
+
{
|
|
27938
|
+
id: "qwen/qwen3.8-max-prime",
|
|
27939
|
+
name: "Qwen3.8 Max Prime",
|
|
27940
|
+
description: "Qwen's flagship tier for complex agentic work",
|
|
27941
|
+
enabled: true,
|
|
27942
|
+
isDefault: false,
|
|
27943
|
+
sortOrder: 80,
|
|
27944
|
+
upstreamModelId: "qwen/qwen3.8-max-prime",
|
|
27945
|
+
contextWindow: 1e6,
|
|
27946
|
+
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS,
|
|
27947
|
+
inputPriceMicroUsdPerMtok: 4e6,
|
|
27948
|
+
outputPriceMicroUsdPerMtok: 12e6,
|
|
27949
|
+
cacheReadPriceMicroUsdPerMtok: 5e5
|
|
27883
27950
|
},
|
|
27884
27951
|
{
|
|
27885
27952
|
id: "moonshotai/kimi-k3",
|
|
@@ -27887,10 +27954,85 @@ var init_models = __esm({
|
|
|
27887
27954
|
description: "Moonshot's 2.8T open-weight flagship",
|
|
27888
27955
|
enabled: true,
|
|
27889
27956
|
isDefault: false,
|
|
27890
|
-
sortOrder:
|
|
27957
|
+
sortOrder: 90,
|
|
27891
27958
|
upstreamModelId: "moonshotai/kimi-k3",
|
|
27892
27959
|
contextWindow: 1048576,
|
|
27893
|
-
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS
|
|
27960
|
+
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS,
|
|
27961
|
+
inputPriceMicroUsdPerMtok: 192e3,
|
|
27962
|
+
outputPriceMicroUsdPerMtok: 15e6,
|
|
27963
|
+
cacheReadPriceMicroUsdPerMtok: 182e3,
|
|
27964
|
+
routing: { tier: "strong", priority: 10, strengths: ["architecture", "long_context"] }
|
|
27965
|
+
},
|
|
27966
|
+
{
|
|
27967
|
+
id: "moonshotai/kimi-k3.1-pro",
|
|
27968
|
+
name: "Kimi K3.1 Pro",
|
|
27969
|
+
description: "Moonshot's updated K3 flagship",
|
|
27970
|
+
enabled: true,
|
|
27971
|
+
isDefault: false,
|
|
27972
|
+
sortOrder: 100,
|
|
27973
|
+
upstreamModelId: "moonshotai/kimi-k3.1-pro",
|
|
27974
|
+
contextWindow: 1048576,
|
|
27975
|
+
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS,
|
|
27976
|
+
inputPriceMicroUsdPerMtok: 2e6,
|
|
27977
|
+
outputPriceMicroUsdPerMtok: 1e7,
|
|
27978
|
+
cacheReadPriceMicroUsdPerMtok: 2e5
|
|
27979
|
+
},
|
|
27980
|
+
{
|
|
27981
|
+
id: "minimax/minimax-m3.1-flash",
|
|
27982
|
+
name: "MiniMax M3.1 Flash",
|
|
27983
|
+
description: "Fast multimodal MiniMax for high-volume work",
|
|
27984
|
+
enabled: true,
|
|
27985
|
+
isDefault: false,
|
|
27986
|
+
sortOrder: 110,
|
|
27987
|
+
upstreamModelId: "minimax/minimax-m3.1-flash",
|
|
27988
|
+
contextWindow: 1048576,
|
|
27989
|
+
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS,
|
|
27990
|
+
inputPriceMicroUsdPerMtok: 15e4,
|
|
27991
|
+
outputPriceMicroUsdPerMtok: 6e5,
|
|
27992
|
+
cacheReadPriceMicroUsdPerMtok: 15e3,
|
|
27993
|
+
routing: { tier: "workhorse", priority: 30, strengths: ["ui_design", "speed"] }
|
|
27994
|
+
},
|
|
27995
|
+
{
|
|
27996
|
+
id: "minimax/minimax-m3",
|
|
27997
|
+
name: "MiniMax M3",
|
|
27998
|
+
description: "MiniMax's full-size multimodal agentic model",
|
|
27999
|
+
enabled: true,
|
|
28000
|
+
isDefault: false,
|
|
28001
|
+
sortOrder: 120,
|
|
28002
|
+
upstreamModelId: "minimax/minimax-m3",
|
|
28003
|
+
contextWindow: 1048576,
|
|
28004
|
+
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS,
|
|
28005
|
+
inputPriceMicroUsdPerMtok: 3e5,
|
|
28006
|
+
outputPriceMicroUsdPerMtok: 12e5,
|
|
28007
|
+
cacheReadPriceMicroUsdPerMtok: 6e4
|
|
28008
|
+
},
|
|
28009
|
+
{
|
|
28010
|
+
id: "nvidia/nemotron-3.5-lightning",
|
|
28011
|
+
name: "Nemotron 3.5 Lightning",
|
|
28012
|
+
description: "Small, fast Nemotron for high-volume work",
|
|
28013
|
+
enabled: true,
|
|
28014
|
+
isDefault: false,
|
|
28015
|
+
sortOrder: 130,
|
|
28016
|
+
upstreamModelId: "nvidia/nemotron-3.5-lightning",
|
|
28017
|
+
contextWindow: 262144,
|
|
28018
|
+
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS,
|
|
28019
|
+
inputPriceMicroUsdPerMtok: 7e4,
|
|
28020
|
+
outputPriceMicroUsdPerMtok: 2e5,
|
|
28021
|
+
cacheReadPriceMicroUsdPerMtok: 4e4
|
|
28022
|
+
},
|
|
28023
|
+
{
|
|
28024
|
+
id: "nvidia/nemotron-3.5-super-vl",
|
|
28025
|
+
name: "Nemotron 3.5 Super VL",
|
|
28026
|
+
description: "Vision-language Nemotron with a 1M-token window",
|
|
28027
|
+
enabled: true,
|
|
28028
|
+
isDefault: false,
|
|
28029
|
+
sortOrder: 140,
|
|
28030
|
+
upstreamModelId: "nvidia/nemotron-3.5-super-vl",
|
|
28031
|
+
contextWindow: 1048576,
|
|
28032
|
+
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS,
|
|
28033
|
+
inputPriceMicroUsdPerMtok: 15e4,
|
|
28034
|
+
outputPriceMicroUsdPerMtok: 5e5,
|
|
28035
|
+
cacheReadPriceMicroUsdPerMtok: 2e4
|
|
27894
28036
|
},
|
|
27895
28037
|
{
|
|
27896
28038
|
id: "nvidia/nemotron-3-nano-30b-a3b",
|
|
@@ -27898,10 +28040,13 @@ var init_models = __esm({
|
|
|
27898
28040
|
description: "Fast Nemotron via Alan",
|
|
27899
28041
|
enabled: true,
|
|
27900
28042
|
isDefault: false,
|
|
27901
|
-
sortOrder:
|
|
28043
|
+
sortOrder: 150,
|
|
27902
28044
|
upstreamModelId: "nvidia/nemotron-3-nano-30b-a3b",
|
|
27903
28045
|
contextWindow: 262144,
|
|
27904
|
-
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS
|
|
28046
|
+
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS,
|
|
28047
|
+
inputPriceMicroUsdPerMtok: 6e4,
|
|
28048
|
+
outputPriceMicroUsdPerMtok: 24e4,
|
|
28049
|
+
cacheReadPriceMicroUsdPerMtok: 12e3
|
|
27905
28050
|
},
|
|
27906
28051
|
{
|
|
27907
28052
|
id: "nvidia/nemotron-3-super-120b-a12b",
|
|
@@ -27909,10 +28054,13 @@ var init_models = __esm({
|
|
|
27909
28054
|
description: "Mid-tier Nemotron via Alan",
|
|
27910
28055
|
enabled: true,
|
|
27911
28056
|
isDefault: false,
|
|
27912
|
-
sortOrder:
|
|
28057
|
+
sortOrder: 160,
|
|
27913
28058
|
upstreamModelId: "nvidia/nemotron-3-super-120b-a12b",
|
|
27914
|
-
contextWindow:
|
|
27915
|
-
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS
|
|
28059
|
+
contextWindow: 1048576,
|
|
28060
|
+
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS,
|
|
28061
|
+
inputPriceMicroUsdPerMtok: 3e5,
|
|
28062
|
+
outputPriceMicroUsdPerMtok: 24e5,
|
|
28063
|
+
cacheReadPriceMicroUsdPerMtok: 15e4
|
|
27916
28064
|
},
|
|
27917
28065
|
{
|
|
27918
28066
|
id: "nvidia/nemotron-3-ultra-550b-a55b",
|
|
@@ -27920,21 +28068,13 @@ var init_models = __esm({
|
|
|
27920
28068
|
description: "Largest Nemotron via Alan",
|
|
27921
28069
|
enabled: true,
|
|
27922
28070
|
isDefault: false,
|
|
27923
|
-
sortOrder:
|
|
28071
|
+
sortOrder: 170,
|
|
27924
28072
|
upstreamModelId: "nvidia/nemotron-3-ultra-550b-a55b",
|
|
27925
28073
|
contextWindow: 262144,
|
|
27926
|
-
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS
|
|
27927
|
-
|
|
27928
|
-
|
|
27929
|
-
|
|
27930
|
-
name: "Nemotron 3.5 Lightning",
|
|
27931
|
-
description: "Small, fast Nemotron for high-volume work",
|
|
27932
|
-
enabled: true,
|
|
27933
|
-
isDefault: false,
|
|
27934
|
-
sortOrder: 100,
|
|
27935
|
-
upstreamModelId: "nvidia/nemotron-3.5-lightning",
|
|
27936
|
-
contextWindow: 262144,
|
|
27937
|
-
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS
|
|
28074
|
+
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS,
|
|
28075
|
+
inputPriceMicroUsdPerMtok: 6e5,
|
|
28076
|
+
outputPriceMicroUsdPerMtok: 24e5,
|
|
28077
|
+
cacheReadPriceMicroUsdPerMtok: 12e4
|
|
27938
28078
|
},
|
|
27939
28079
|
{
|
|
27940
28080
|
id: "meta/muse-spark-1.3-contributor",
|
|
@@ -27942,10 +28082,13 @@ var init_models = __esm({
|
|
|
27942
28082
|
description: "Cost-efficient Muse Spark (contributor tier)",
|
|
27943
28083
|
enabled: true,
|
|
27944
28084
|
isDefault: false,
|
|
27945
|
-
sortOrder:
|
|
28085
|
+
sortOrder: 180,
|
|
27946
28086
|
upstreamModelId: "meta/muse-spark-1.3-contributor",
|
|
27947
28087
|
contextWindow: 1048576,
|
|
27948
|
-
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS
|
|
28088
|
+
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS,
|
|
28089
|
+
inputPriceMicroUsdPerMtok: 1e5,
|
|
28090
|
+
outputPriceMicroUsdPerMtok: 2e5,
|
|
28091
|
+
cacheReadPriceMicroUsdPerMtok: 2e3
|
|
27949
28092
|
},
|
|
27950
28093
|
{
|
|
27951
28094
|
id: "meta/muse-spark-1.3",
|
|
@@ -27953,10 +28096,41 @@ var init_models = __esm({
|
|
|
27953
28096
|
description: "Meta Muse Spark multimodal agentic coding",
|
|
27954
28097
|
enabled: true,
|
|
27955
28098
|
isDefault: false,
|
|
27956
|
-
sortOrder:
|
|
28099
|
+
sortOrder: 190,
|
|
27957
28100
|
upstreamModelId: "meta/muse-spark-1.3",
|
|
27958
28101
|
contextWindow: 1048576,
|
|
27959
|
-
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS
|
|
28102
|
+
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS,
|
|
28103
|
+
inputPriceMicroUsdPerMtok: 125e4,
|
|
28104
|
+
outputPriceMicroUsdPerMtok: 425e4,
|
|
28105
|
+
cacheReadPriceMicroUsdPerMtok: 15e4
|
|
28106
|
+
},
|
|
28107
|
+
{
|
|
28108
|
+
id: "meta/muse-spark-open",
|
|
28109
|
+
name: "Muse Spark Open",
|
|
28110
|
+
description: "Open-weight Muse Spark with audio and video input",
|
|
28111
|
+
enabled: true,
|
|
28112
|
+
isDefault: false,
|
|
28113
|
+
sortOrder: 200,
|
|
28114
|
+
upstreamModelId: "meta/muse-spark-open",
|
|
28115
|
+
contextWindow: 1048576,
|
|
28116
|
+
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS,
|
|
28117
|
+
inputPriceMicroUsdPerMtok: 125e4,
|
|
28118
|
+
outputPriceMicroUsdPerMtok: 425e4,
|
|
28119
|
+
cacheReadPriceMicroUsdPerMtok: 15e4
|
|
28120
|
+
},
|
|
28121
|
+
{
|
|
28122
|
+
id: "meta/muse-wonder",
|
|
28123
|
+
name: "Muse Wonder",
|
|
28124
|
+
description: "Meta's premium Muse tier",
|
|
28125
|
+
enabled: true,
|
|
28126
|
+
isDefault: false,
|
|
28127
|
+
sortOrder: 210,
|
|
28128
|
+
upstreamModelId: "meta/muse-wonder",
|
|
28129
|
+
contextWindow: 1048576,
|
|
28130
|
+
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS,
|
|
28131
|
+
inputPriceMicroUsdPerMtok: 4e6,
|
|
28132
|
+
outputPriceMicroUsdPerMtok: 2e7,
|
|
28133
|
+
cacheReadPriceMicroUsdPerMtok: 2e5
|
|
27960
28134
|
},
|
|
27961
28135
|
{
|
|
27962
28136
|
id: "meta/muse-spark-1.2-contributor",
|
|
@@ -27964,32 +28138,41 @@ var init_models = __esm({
|
|
|
27964
28138
|
description: "Prior Muse Spark contributor tier",
|
|
27965
28139
|
enabled: true,
|
|
27966
28140
|
isDefault: false,
|
|
27967
|
-
sortOrder:
|
|
28141
|
+
sortOrder: 220,
|
|
27968
28142
|
upstreamModelId: "meta/muse-spark-1.2-contributor",
|
|
27969
28143
|
contextWindow: 1048576,
|
|
27970
|
-
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS
|
|
28144
|
+
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS,
|
|
28145
|
+
inputPriceMicroUsdPerMtok: 1e5,
|
|
28146
|
+
outputPriceMicroUsdPerMtok: 2e5,
|
|
28147
|
+
cacheReadPriceMicroUsdPerMtok: 2e3
|
|
27971
28148
|
},
|
|
27972
28149
|
{
|
|
27973
|
-
id: "
|
|
27974
|
-
name: "
|
|
27975
|
-
description: "
|
|
28150
|
+
id: "x-ai/grok-4.7",
|
|
28151
|
+
name: "Grok 4.7",
|
|
28152
|
+
description: "xAI's current Grok for agentic coding",
|
|
27976
28153
|
enabled: true,
|
|
27977
28154
|
isDefault: false,
|
|
27978
|
-
sortOrder:
|
|
27979
|
-
upstreamModelId: "
|
|
27980
|
-
contextWindow:
|
|
27981
|
-
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS
|
|
28155
|
+
sortOrder: 230,
|
|
28156
|
+
upstreamModelId: "x-ai/grok-4.7",
|
|
28157
|
+
contextWindow: 5e5,
|
|
28158
|
+
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS,
|
|
28159
|
+
inputPriceMicroUsdPerMtok: 2e6,
|
|
28160
|
+
outputPriceMicroUsdPerMtok: 6e6,
|
|
28161
|
+
cacheReadPriceMicroUsdPerMtok: 5e5
|
|
27982
28162
|
},
|
|
27983
28163
|
{
|
|
27984
|
-
id: "
|
|
27985
|
-
name: "
|
|
27986
|
-
description: "
|
|
28164
|
+
id: "google/gemini-4-argon",
|
|
28165
|
+
name: "Gemini 4 Argon",
|
|
28166
|
+
description: "Google's flagship reasoning model for complex software work",
|
|
27987
28167
|
enabled: true,
|
|
27988
28168
|
isDefault: false,
|
|
27989
|
-
sortOrder:
|
|
27990
|
-
upstreamModelId: "
|
|
28169
|
+
sortOrder: 240,
|
|
28170
|
+
upstreamModelId: "google/gemini-4-argon",
|
|
27991
28171
|
contextWindow: 1048576,
|
|
27992
|
-
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS
|
|
28172
|
+
maxOutputTokens: HARNESS_MAX_OUTPUT_TOKENS,
|
|
28173
|
+
inputPriceMicroUsdPerMtok: 2e6,
|
|
28174
|
+
outputPriceMicroUsdPerMtok: 1e7,
|
|
28175
|
+
cacheReadPriceMicroUsdPerMtok: 1e5
|
|
27993
28176
|
}
|
|
27994
28177
|
];
|
|
27995
28178
|
DEFAULT_HARNESS_MODEL_ID = HARNESS_MODEL_SEEDS.find((model) => model.isDefault)?.id ?? HARNESS_MODEL_SEEDS[0].id;
|
|
@@ -33778,7 +33961,7 @@ function readText2(incoming, maxBytes) {
|
|
|
33778
33961
|
incoming.on("error", reject);
|
|
33779
33962
|
});
|
|
33780
33963
|
}
|
|
33781
|
-
var import_node_crypto20, import_node_http4, IDLE_SOCKET_MS3, OpenCodeHttpError, BASE62, messageIdClock, OpenCodeClient;
|
|
33964
|
+
var import_node_crypto20, import_node_http4, IDLE_SOCKET_MS3, OpenCodeHttpError, OpenCodeTimeoutError, BASE62, messageIdClock, OpenCodeClient;
|
|
33782
33965
|
var init_client = __esm({
|
|
33783
33966
|
"../agent-core/src/providers/opencode/client.ts"() {
|
|
33784
33967
|
"use strict";
|
|
@@ -33796,6 +33979,12 @@ var init_client = __esm({
|
|
|
33796
33979
|
this.body = body;
|
|
33797
33980
|
}
|
|
33798
33981
|
};
|
|
33982
|
+
OpenCodeTimeoutError = class extends Error {
|
|
33983
|
+
constructor(what, ms, engine = "OpenCode") {
|
|
33984
|
+
super(`${engine} ${what} request timed out after ${ms} ms`);
|
|
33985
|
+
this.name = "OpenCodeTimeoutError";
|
|
33986
|
+
}
|
|
33987
|
+
};
|
|
33799
33988
|
BASE62 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
|
|
33800
33989
|
messageIdClock = { at: 0, counter: 0 };
|
|
33801
33990
|
OpenCodeClient = class {
|
|
@@ -33823,6 +34012,7 @@ var init_client = __esm({
|
|
|
33823
34012
|
}
|
|
33824
34013
|
#open(call) {
|
|
33825
34014
|
return new Promise((resolve16, reject) => {
|
|
34015
|
+
const deadline = AbortSignal.timeout(this.#limits.requestTimeoutMs);
|
|
33826
34016
|
const outgoing = (0, import_node_http4.request)(
|
|
33827
34017
|
`${this.baseUrl}${call.path}`,
|
|
33828
34018
|
{
|
|
@@ -33830,20 +34020,26 @@ var init_client = __esm({
|
|
|
33830
34020
|
headers: call.headers,
|
|
33831
34021
|
agent: this.#agent,
|
|
33832
34022
|
timeout: call.stream ? this.#limits.streamIdleMs : this.#limits.requestTimeoutMs,
|
|
33833
|
-
signal: call.stream ? this.#lifetime.signal : AbortSignal.any([
|
|
33834
|
-
this.#lifetime.signal,
|
|
33835
|
-
AbortSignal.timeout(this.#limits.requestTimeoutMs)
|
|
33836
|
-
])
|
|
34023
|
+
signal: call.stream ? this.#lifetime.signal : AbortSignal.any([this.#lifetime.signal, deadline])
|
|
33837
34024
|
},
|
|
33838
34025
|
resolve16
|
|
33839
34026
|
);
|
|
33840
|
-
outgoing.on("timeout", () => outgoing.destroy(
|
|
33841
|
-
outgoing.on("error",
|
|
34027
|
+
outgoing.on("timeout", () => outgoing.destroy(this.#timedOut(call)));
|
|
34028
|
+
outgoing.on("error", (error62) => {
|
|
34029
|
+
const expired = !call.stream && deadline.aborted && !this.#lifetime.signal.aborted;
|
|
34030
|
+
reject(expired ? this.#timedOut(call) : error62);
|
|
34031
|
+
});
|
|
33842
34032
|
outgoing.end(call.body);
|
|
33843
34033
|
});
|
|
33844
34034
|
}
|
|
34035
|
+
/** A quiet event stream stays a plain Error: a first start may still be installing, so it is not retried. */
|
|
34036
|
+
#timedOut(call) {
|
|
34037
|
+
if (call.stream) return new Error("OpenCode request timed out");
|
|
34038
|
+
return new OpenCodeTimeoutError(call.what, this.#limits.requestTimeoutMs, this.#engine);
|
|
34039
|
+
}
|
|
33845
34040
|
async #call(what, method, path4, body) {
|
|
33846
34041
|
const response = await this.#open({
|
|
34042
|
+
what,
|
|
33847
34043
|
method,
|
|
33848
34044
|
path: path4,
|
|
33849
34045
|
headers: {
|
|
@@ -33982,6 +34178,7 @@ var init_client = __esm({
|
|
|
33982
34178
|
/** Subscribes to the server-wide bus. */
|
|
33983
34179
|
async events(handlers) {
|
|
33984
34180
|
const response = await this.#open({
|
|
34181
|
+
what: "event stream",
|
|
33985
34182
|
method: "GET",
|
|
33986
34183
|
path: "/event",
|
|
33987
34184
|
stream: true,
|
|
@@ -35743,6 +35940,7 @@ async function openSession(client, session, spec, log) {
|
|
|
35743
35940
|
return { id, resumed: false };
|
|
35744
35941
|
}
|
|
35745
35942
|
function isOpenTimeout(error62) {
|
|
35943
|
+
if (error62 instanceof OpenCodeTimeoutError) return true;
|
|
35746
35944
|
return error62 instanceof CoreFault && error62.code === "protocol_violation";
|
|
35747
35945
|
}
|
|
35748
35946
|
async function openOnce(spec, password, options) {
|
|
@@ -35758,7 +35956,9 @@ async function openOnce(spec, password, options) {
|
|
|
35758
35956
|
throw error62;
|
|
35759
35957
|
});
|
|
35760
35958
|
try {
|
|
35761
|
-
const client = new OpenCodeClient(url3, password, options.engine.label
|
|
35959
|
+
const client = new OpenCodeClient(url3, password, options.engine.label, {
|
|
35960
|
+
requestTimeoutMs: options.requestTimeoutMs
|
|
35961
|
+
});
|
|
35762
35962
|
const alive = (work) => whileAlive(session, options, work);
|
|
35763
35963
|
await withDeadline2(
|
|
35764
35964
|
alive(checkHealth(client, options.log)),
|
|
@@ -35807,24 +36007,33 @@ async function openWithRetries(spec, password, options) {
|
|
|
35807
36007
|
}
|
|
35808
36008
|
}
|
|
35809
36009
|
}
|
|
35810
|
-
function
|
|
35811
|
-
|
|
36010
|
+
function resolveOpenLimits(options) {
|
|
36011
|
+
return {
|
|
36012
|
+
openTimeoutMs: options.openTimeoutMs ?? DEFAULTS2.openTimeoutMs,
|
|
36013
|
+
requestTimeoutMs: options.requestTimeoutMs ?? DEFAULTS2.requestTimeoutMs,
|
|
36014
|
+
bootstrapTimeoutMs: options.bootstrapTimeoutMs ?? DEFAULTS2.bootstrapTimeoutMs,
|
|
36015
|
+
slowBootstrapMs: options.slowBootstrapMs ?? DEFAULTS2.slowBootstrapMs,
|
|
36016
|
+
openAttempts: options.openAttempts ?? DEFAULTS2.openAttempts,
|
|
36017
|
+
startAttempts: options.startAttempts ?? DEFAULTS2.startAttempts
|
|
36018
|
+
};
|
|
36019
|
+
}
|
|
36020
|
+
function resolveOptions(options) {
|
|
36021
|
+
return {
|
|
35812
36022
|
clock: options.clock ?? systemClock2,
|
|
35813
36023
|
log: options.log ?? silentLog,
|
|
35814
36024
|
interruptGraceMs: options.interruptGraceMs ?? DEFAULTS2.interruptGraceMs,
|
|
35815
36025
|
terminateGraceMs: options.terminateGraceMs ?? DEFAULTS2.terminateGraceMs,
|
|
35816
36026
|
stdoutDrainMs: options.stdoutDrainMs ?? DEFAULTS2.stdoutDrainMs,
|
|
35817
36027
|
descendantScanMs: options.descendantScanMs ?? DEFAULTS2.descendantScanMs,
|
|
35818
|
-
openTimeoutMs: options.openTimeoutMs ?? DEFAULTS2.openTimeoutMs,
|
|
35819
|
-
bootstrapTimeoutMs: options.bootstrapTimeoutMs ?? DEFAULTS2.bootstrapTimeoutMs,
|
|
35820
|
-
slowBootstrapMs: options.slowBootstrapMs ?? DEFAULTS2.slowBootstrapMs,
|
|
35821
|
-
openAttempts: options.openAttempts ?? DEFAULTS2.openAttempts,
|
|
35822
|
-
startAttempts: options.startAttempts ?? DEFAULTS2.startAttempts,
|
|
35823
36028
|
reconnectAttempts: options.reconnectAttempts ?? DEFAULTS2.reconnectAttempts,
|
|
35824
36029
|
reconnectDelayMs: options.reconnectDelayMs ?? DEFAULTS2.reconnectDelayMs,
|
|
35825
36030
|
engine: options.engine ?? OPENCODE_ENGINE,
|
|
35826
|
-
stopTaskTimeoutMs: options.stopTaskTimeoutMs ?? DEFAULTS2.stopTaskTimeoutMs
|
|
36031
|
+
stopTaskTimeoutMs: options.stopTaskTimeoutMs ?? DEFAULTS2.stopTaskTimeoutMs,
|
|
36032
|
+
...resolveOpenLimits(options)
|
|
35827
36033
|
};
|
|
36034
|
+
}
|
|
36035
|
+
function createOpenCodeDriver(options = {}) {
|
|
36036
|
+
const resolved = resolveOptions(options);
|
|
35828
36037
|
return {
|
|
35829
36038
|
name: "opencode_serve",
|
|
35830
36039
|
open: async (planned) => {
|
|
@@ -35877,6 +36086,7 @@ var init_driver3 = __esm({
|
|
|
35877
36086
|
stdoutDrainMs: 2e3,
|
|
35878
36087
|
descendantScanMs: 5e3,
|
|
35879
36088
|
openTimeoutMs: 6e4,
|
|
36089
|
+
requestTimeoutMs: 3e4,
|
|
35880
36090
|
bootstrapTimeoutMs: 6e5,
|
|
35881
36091
|
slowBootstrapMs: 5e3,
|
|
35882
36092
|
openAttempts: 2,
|
|
@@ -42079,8 +42289,8 @@ function itemCompleted(payload, state) {
|
|
|
42079
42289
|
const item = asRecord(payload.item);
|
|
42080
42290
|
const updates = item ? parseCompletedItem(item, state) : null;
|
|
42081
42291
|
if (updates) return updates;
|
|
42082
|
-
const
|
|
42083
|
-
return [unhandledUpdate(`rollout.item.${asString(item?.type)}${
|
|
42292
|
+
const extension2 = item?.type === "Extension" ? `/${asString(item.kind)}` : "";
|
|
42293
|
+
return [unhandledUpdate(`rollout.item.${asString(item?.type)}${extension2}`, payload)];
|
|
42084
42294
|
}
|
|
42085
42295
|
function readableCodexError(message2) {
|
|
42086
42296
|
try {
|
|
@@ -56619,15 +56829,16 @@ var require_src = __commonJS({
|
|
|
56619
56829
|
}
|
|
56620
56830
|
});
|
|
56621
56831
|
|
|
56622
|
-
// ../../node_modules/
|
|
56832
|
+
// ../../node_modules/ws/lib/constants.js
|
|
56623
56833
|
var require_constants2 = __commonJS({
|
|
56624
|
-
"../../node_modules/
|
|
56834
|
+
"../../node_modules/ws/lib/constants.js"(exports2, module2) {
|
|
56625
56835
|
"use strict";
|
|
56626
56836
|
var BINARY_TYPES = ["nodebuffer", "arraybuffer", "fragments"];
|
|
56627
56837
|
var hasBlob = typeof Blob !== "undefined";
|
|
56628
56838
|
if (hasBlob) BINARY_TYPES.push("blob");
|
|
56629
56839
|
module2.exports = {
|
|
56630
56840
|
BINARY_TYPES,
|
|
56841
|
+
CLOSE_TIMEOUT: 3e4,
|
|
56631
56842
|
EMPTY_BUFFER: Buffer.alloc(0),
|
|
56632
56843
|
GUID: "258EAFA5-E914-47DA-95CA-C5AB0DC85B11",
|
|
56633
56844
|
hasBlob,
|
|
@@ -56641,9 +56852,9 @@ var require_constants2 = __commonJS({
|
|
|
56641
56852
|
}
|
|
56642
56853
|
});
|
|
56643
56854
|
|
|
56644
|
-
// ../../node_modules/
|
|
56855
|
+
// ../../node_modules/ws/lib/buffer-util.js
|
|
56645
56856
|
var require_buffer_util = __commonJS({
|
|
56646
|
-
"../../node_modules/
|
|
56857
|
+
"../../node_modules/ws/lib/buffer-util.js"(exports2, module2) {
|
|
56647
56858
|
"use strict";
|
|
56648
56859
|
var { EMPTY_BUFFER } = require_constants2();
|
|
56649
56860
|
var FastBuffer = Buffer[Symbol.species];
|
|
@@ -56716,9 +56927,9 @@ var require_buffer_util = __commonJS({
|
|
|
56716
56927
|
}
|
|
56717
56928
|
});
|
|
56718
56929
|
|
|
56719
|
-
// ../../node_modules/
|
|
56930
|
+
// ../../node_modules/ws/lib/limiter.js
|
|
56720
56931
|
var require_limiter = __commonJS({
|
|
56721
|
-
"../../node_modules/
|
|
56932
|
+
"../../node_modules/ws/lib/limiter.js"(exports2, module2) {
|
|
56722
56933
|
"use strict";
|
|
56723
56934
|
var kDone = /* @__PURE__ */ Symbol("kDone");
|
|
56724
56935
|
var kRun = /* @__PURE__ */ Symbol("kRun");
|
|
@@ -56766,9 +56977,9 @@ var require_limiter = __commonJS({
|
|
|
56766
56977
|
}
|
|
56767
56978
|
});
|
|
56768
56979
|
|
|
56769
|
-
// ../../node_modules/
|
|
56980
|
+
// ../../node_modules/ws/lib/permessage-deflate.js
|
|
56770
56981
|
var require_permessage_deflate = __commonJS({
|
|
56771
|
-
"../../node_modules/
|
|
56982
|
+
"../../node_modules/ws/lib/permessage-deflate.js"(exports2, module2) {
|
|
56772
56983
|
"use strict";
|
|
56773
56984
|
var zlib = require("zlib");
|
|
56774
56985
|
var bufferUtil = require_buffer_util();
|
|
@@ -56782,7 +56993,7 @@ var require_permessage_deflate = __commonJS({
|
|
|
56782
56993
|
var kBuffers = /* @__PURE__ */ Symbol("buffers");
|
|
56783
56994
|
var kError = /* @__PURE__ */ Symbol("error");
|
|
56784
56995
|
var zlibLimiter;
|
|
56785
|
-
var
|
|
56996
|
+
var PerMessageDeflate2 = class {
|
|
56786
56997
|
/**
|
|
56787
56998
|
* Creates a PerMessageDeflate instance.
|
|
56788
56999
|
*
|
|
@@ -56793,6 +57004,9 @@ var require_permessage_deflate = __commonJS({
|
|
|
56793
57004
|
* acknowledge disabling of client context takeover
|
|
56794
57005
|
* @param {Number} [options.concurrencyLimit=10] The number of concurrent
|
|
56795
57006
|
* calls to zlib
|
|
57007
|
+
* @param {Boolean} [options.isServer=false] Create the instance in either
|
|
57008
|
+
* server or client mode
|
|
57009
|
+
* @param {Number} [options.maxPayload=0] The maximum allowed message length
|
|
56796
57010
|
* @param {(Boolean|Number)} [options.serverMaxWindowBits] Request/confirm the
|
|
56797
57011
|
* use of a custom server window size
|
|
56798
57012
|
* @param {Boolean} [options.serverNoContextTakeover=false] Request/accept
|
|
@@ -56803,15 +57017,12 @@ var require_permessage_deflate = __commonJS({
|
|
|
56803
57017
|
* deflate
|
|
56804
57018
|
* @param {Object} [options.zlibInflateOptions] Options to pass to zlib on
|
|
56805
57019
|
* inflate
|
|
56806
|
-
* @param {Boolean} [isServer=false] Create the instance in either server or
|
|
56807
|
-
* client mode
|
|
56808
|
-
* @param {Number} [maxPayload=0] The maximum allowed message length
|
|
56809
57020
|
*/
|
|
56810
|
-
constructor(options
|
|
56811
|
-
this._maxPayload = maxPayload | 0;
|
|
57021
|
+
constructor(options) {
|
|
56812
57022
|
this._options = options || {};
|
|
56813
57023
|
this._threshold = this._options.threshold !== void 0 ? this._options.threshold : 1024;
|
|
56814
|
-
this.
|
|
57024
|
+
this._maxPayload = this._options.maxPayload | 0;
|
|
57025
|
+
this._isServer = !!this._options.isServer;
|
|
56815
57026
|
this._deflate = null;
|
|
56816
57027
|
this._inflate = null;
|
|
56817
57028
|
this.params = null;
|
|
@@ -57120,7 +57331,7 @@ var require_permessage_deflate = __commonJS({
|
|
|
57120
57331
|
});
|
|
57121
57332
|
}
|
|
57122
57333
|
};
|
|
57123
|
-
module2.exports =
|
|
57334
|
+
module2.exports = PerMessageDeflate2;
|
|
57124
57335
|
function deflateOnData(chunk) {
|
|
57125
57336
|
this[kBuffers].push(chunk);
|
|
57126
57337
|
this[kTotalLength] += chunk.length;
|
|
@@ -57149,9 +57360,9 @@ var require_permessage_deflate = __commonJS({
|
|
|
57149
57360
|
}
|
|
57150
57361
|
});
|
|
57151
57362
|
|
|
57152
|
-
// ../../node_modules/
|
|
57363
|
+
// ../../node_modules/ws/lib/validation.js
|
|
57153
57364
|
var require_validation = __commonJS({
|
|
57154
|
-
"../../node_modules/
|
|
57365
|
+
"../../node_modules/ws/lib/validation.js"(exports2, module2) {
|
|
57155
57366
|
"use strict";
|
|
57156
57367
|
var { isUtf8 } = require("buffer");
|
|
57157
57368
|
var { hasBlob } = require_constants2();
|
|
@@ -57350,12 +57561,12 @@ var require_validation = __commonJS({
|
|
|
57350
57561
|
}
|
|
57351
57562
|
});
|
|
57352
57563
|
|
|
57353
|
-
// ../../node_modules/
|
|
57564
|
+
// ../../node_modules/ws/lib/receiver.js
|
|
57354
57565
|
var require_receiver = __commonJS({
|
|
57355
|
-
"../../node_modules/
|
|
57566
|
+
"../../node_modules/ws/lib/receiver.js"(exports2, module2) {
|
|
57356
57567
|
"use strict";
|
|
57357
57568
|
var { Writable } = require("stream");
|
|
57358
|
-
var
|
|
57569
|
+
var PerMessageDeflate2 = require_permessage_deflate();
|
|
57359
57570
|
var {
|
|
57360
57571
|
BINARY_TYPES,
|
|
57361
57572
|
EMPTY_BUFFER,
|
|
@@ -57385,6 +57596,10 @@ var require_receiver = __commonJS({
|
|
|
57385
57596
|
* extensions
|
|
57386
57597
|
* @param {Boolean} [options.isServer=false] Specifies whether to operate in
|
|
57387
57598
|
* client or server mode
|
|
57599
|
+
* @param {Number} [options.maxBufferedChunks=0] The maximum number of
|
|
57600
|
+
* buffered data chunks
|
|
57601
|
+
* @param {Number} [options.maxFragments=0] The maximum number of message
|
|
57602
|
+
* fragments
|
|
57388
57603
|
* @param {Number} [options.maxPayload=0] The maximum allowed message length
|
|
57389
57604
|
* @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
|
|
57390
57605
|
* not to skip UTF-8 validation for text and close messages
|
|
@@ -57395,6 +57610,8 @@ var require_receiver = __commonJS({
|
|
|
57395
57610
|
this._binaryType = options.binaryType || BINARY_TYPES[0];
|
|
57396
57611
|
this._extensions = options.extensions || {};
|
|
57397
57612
|
this._isServer = !!options.isServer;
|
|
57613
|
+
this._maxBufferedChunks = options.maxBufferedChunks | 0;
|
|
57614
|
+
this._maxFragments = options.maxFragments | 0;
|
|
57398
57615
|
this._maxPayload = options.maxPayload | 0;
|
|
57399
57616
|
this._skipUTF8Validation = !!options.skipUTF8Validation;
|
|
57400
57617
|
this[kWebSocket] = void 0;
|
|
@@ -57409,6 +57626,7 @@ var require_receiver = __commonJS({
|
|
|
57409
57626
|
this._opcode = 0;
|
|
57410
57627
|
this._totalPayloadLength = 0;
|
|
57411
57628
|
this._messageLength = 0;
|
|
57629
|
+
this._numFragments = 0;
|
|
57412
57630
|
this._fragments = [];
|
|
57413
57631
|
this._errored = false;
|
|
57414
57632
|
this._loop = false;
|
|
@@ -57424,6 +57642,18 @@ var require_receiver = __commonJS({
|
|
|
57424
57642
|
*/
|
|
57425
57643
|
_write(chunk, encoding, cb) {
|
|
57426
57644
|
if (this._opcode === 8 && this._state == GET_INFO) return cb();
|
|
57645
|
+
if (this._maxBufferedChunks > 0 && this._buffers.length >= this._maxBufferedChunks) {
|
|
57646
|
+
cb(
|
|
57647
|
+
this.createError(
|
|
57648
|
+
RangeError,
|
|
57649
|
+
"Too many buffered chunks",
|
|
57650
|
+
false,
|
|
57651
|
+
1008,
|
|
57652
|
+
"WS_ERR_TOO_MANY_BUFFERED_PARTS"
|
|
57653
|
+
)
|
|
57654
|
+
);
|
|
57655
|
+
return;
|
|
57656
|
+
}
|
|
57427
57657
|
this._bufferedBytes += chunk.length;
|
|
57428
57658
|
this._buffers.push(chunk);
|
|
57429
57659
|
this.startLoop(cb);
|
|
@@ -57522,7 +57752,7 @@ var require_receiver = __commonJS({
|
|
|
57522
57752
|
return;
|
|
57523
57753
|
}
|
|
57524
57754
|
const compressed = (buf[0] & 64) === 64;
|
|
57525
|
-
if (compressed && !this._extensions[
|
|
57755
|
+
if (compressed && !this._extensions[PerMessageDeflate2.extensionName]) {
|
|
57526
57756
|
const error62 = this.createError(
|
|
57527
57757
|
RangeError,
|
|
57528
57758
|
"RSV1 must be clear",
|
|
@@ -57747,6 +57977,17 @@ var require_receiver = __commonJS({
|
|
|
57747
57977
|
this.controlMessage(data, cb);
|
|
57748
57978
|
return;
|
|
57749
57979
|
}
|
|
57980
|
+
if (this._maxFragments > 0 && ++this._numFragments > this._maxFragments) {
|
|
57981
|
+
const error62 = this.createError(
|
|
57982
|
+
RangeError,
|
|
57983
|
+
"Too many message fragments",
|
|
57984
|
+
false,
|
|
57985
|
+
1008,
|
|
57986
|
+
"WS_ERR_TOO_MANY_BUFFERED_PARTS"
|
|
57987
|
+
);
|
|
57988
|
+
cb(error62);
|
|
57989
|
+
return;
|
|
57990
|
+
}
|
|
57750
57991
|
if (this._compressed) {
|
|
57751
57992
|
this._state = INFLATING;
|
|
57752
57993
|
this.decompress(data, cb);
|
|
@@ -57766,7 +58007,7 @@ var require_receiver = __commonJS({
|
|
|
57766
58007
|
* @private
|
|
57767
58008
|
*/
|
|
57768
58009
|
decompress(data, cb) {
|
|
57769
|
-
const perMessageDeflate = this._extensions[
|
|
58010
|
+
const perMessageDeflate = this._extensions[PerMessageDeflate2.extensionName];
|
|
57770
58011
|
perMessageDeflate.decompress(data, this._fin, (err, buf) => {
|
|
57771
58012
|
if (err) return cb(err);
|
|
57772
58013
|
if (buf.length) {
|
|
@@ -57804,6 +58045,7 @@ var require_receiver = __commonJS({
|
|
|
57804
58045
|
this._totalPayloadLength = 0;
|
|
57805
58046
|
this._messageLength = 0;
|
|
57806
58047
|
this._fragmented = 0;
|
|
58048
|
+
this._numFragments = 0;
|
|
57807
58049
|
this._fragments = [];
|
|
57808
58050
|
if (this._opcode === 2) {
|
|
57809
58051
|
let data;
|
|
@@ -57942,13 +58184,16 @@ var require_receiver = __commonJS({
|
|
|
57942
58184
|
}
|
|
57943
58185
|
});
|
|
57944
58186
|
|
|
57945
|
-
// ../../node_modules/
|
|
58187
|
+
// ../../node_modules/ws/lib/sender.js
|
|
57946
58188
|
var require_sender = __commonJS({
|
|
57947
|
-
"../../node_modules/
|
|
58189
|
+
"../../node_modules/ws/lib/sender.js"(exports2, module2) {
|
|
57948
58190
|
"use strict";
|
|
57949
58191
|
var { Duplex } = require("stream");
|
|
57950
58192
|
var { randomFillSync } = require("crypto");
|
|
57951
|
-
var
|
|
58193
|
+
var {
|
|
58194
|
+
types: { isUint8Array }
|
|
58195
|
+
} = require("util");
|
|
58196
|
+
var PerMessageDeflate2 = require_permessage_deflate();
|
|
57952
58197
|
var { EMPTY_BUFFER, kWebSocket, NOOP } = require_constants2();
|
|
57953
58198
|
var { isBlob, isValidStatusCode } = require_validation();
|
|
57954
58199
|
var { mask: applyMask, toBuffer: toBuffer2 } = require_buffer_util();
|
|
@@ -58101,8 +58346,10 @@ var require_sender = __commonJS({
|
|
|
58101
58346
|
buf.writeUInt16BE(code, 0);
|
|
58102
58347
|
if (typeof data === "string") {
|
|
58103
58348
|
buf.write(data, 2);
|
|
58104
|
-
} else {
|
|
58349
|
+
} else if (isUint8Array(data)) {
|
|
58105
58350
|
buf.set(data, 2);
|
|
58351
|
+
} else {
|
|
58352
|
+
throw new TypeError("Second argument must be a string or a Uint8Array");
|
|
58106
58353
|
}
|
|
58107
58354
|
}
|
|
58108
58355
|
const options = {
|
|
@@ -58232,7 +58479,7 @@ var require_sender = __commonJS({
|
|
|
58232
58479
|
* @public
|
|
58233
58480
|
*/
|
|
58234
58481
|
send(data, options, cb) {
|
|
58235
|
-
const perMessageDeflate = this._extensions[
|
|
58482
|
+
const perMessageDeflate = this._extensions[PerMessageDeflate2.extensionName];
|
|
58236
58483
|
let opcode = options.binary ? 2 : 1;
|
|
58237
58484
|
let rsv1 = options.compress;
|
|
58238
58485
|
let byteLength3;
|
|
@@ -58356,7 +58603,7 @@ var require_sender = __commonJS({
|
|
|
58356
58603
|
this.sendFrame(_Sender.frame(data, options), cb);
|
|
58357
58604
|
return;
|
|
58358
58605
|
}
|
|
58359
|
-
const perMessageDeflate = this._extensions[
|
|
58606
|
+
const perMessageDeflate = this._extensions[PerMessageDeflate2.extensionName];
|
|
58360
58607
|
this._bufferedBytes += options[kByteLength];
|
|
58361
58608
|
this._state = DEFLATING;
|
|
58362
58609
|
perMessageDeflate.compress(data, options.fin, (_, buf) => {
|
|
@@ -58430,9 +58677,9 @@ var require_sender = __commonJS({
|
|
|
58430
58677
|
}
|
|
58431
58678
|
});
|
|
58432
58679
|
|
|
58433
|
-
// ../../node_modules/
|
|
58680
|
+
// ../../node_modules/ws/lib/event-target.js
|
|
58434
58681
|
var require_event_target = __commonJS({
|
|
58435
|
-
"../../node_modules/
|
|
58682
|
+
"../../node_modules/ws/lib/event-target.js"(exports2, module2) {
|
|
58436
58683
|
"use strict";
|
|
58437
58684
|
var { kForOnEventAttribute, kListener } = require_constants2();
|
|
58438
58685
|
var kCode = /* @__PURE__ */ Symbol("kCode");
|
|
@@ -58659,9 +58906,9 @@ var require_event_target = __commonJS({
|
|
|
58659
58906
|
}
|
|
58660
58907
|
});
|
|
58661
58908
|
|
|
58662
|
-
// ../../node_modules/
|
|
58909
|
+
// ../../node_modules/ws/lib/extension.js
|
|
58663
58910
|
var require_extension = __commonJS({
|
|
58664
|
-
"../../node_modules/
|
|
58911
|
+
"../../node_modules/ws/lib/extension.js"(exports2, module2) {
|
|
58665
58912
|
"use strict";
|
|
58666
58913
|
var { tokenChars } = require_validation();
|
|
58667
58914
|
function push2(dest, name, elem) {
|
|
@@ -58794,11 +59041,11 @@ var require_extension = __commonJS({
|
|
|
58794
59041
|
return offers;
|
|
58795
59042
|
}
|
|
58796
59043
|
function format(extensions) {
|
|
58797
|
-
return Object.keys(extensions).map((
|
|
58798
|
-
let configurations = extensions[
|
|
59044
|
+
return Object.keys(extensions).map((extension2) => {
|
|
59045
|
+
let configurations = extensions[extension2];
|
|
58799
59046
|
if (!Array.isArray(configurations)) configurations = [configurations];
|
|
58800
59047
|
return configurations.map((params) => {
|
|
58801
|
-
return [
|
|
59048
|
+
return [extension2].concat(
|
|
58802
59049
|
Object.keys(params).map((k) => {
|
|
58803
59050
|
let values = params[k];
|
|
58804
59051
|
if (!Array.isArray(values)) values = [values];
|
|
@@ -58812,9 +59059,9 @@ var require_extension = __commonJS({
|
|
|
58812
59059
|
}
|
|
58813
59060
|
});
|
|
58814
59061
|
|
|
58815
|
-
// ../../node_modules/
|
|
59062
|
+
// ../../node_modules/ws/lib/websocket.js
|
|
58816
59063
|
var require_websocket = __commonJS({
|
|
58817
|
-
"../../node_modules/
|
|
59064
|
+
"../../node_modules/ws/lib/websocket.js"(exports2, module2) {
|
|
58818
59065
|
"use strict";
|
|
58819
59066
|
var EventEmitter = require("events");
|
|
58820
59067
|
var https = require("https");
|
|
@@ -58824,12 +59071,13 @@ var require_websocket = __commonJS({
|
|
|
58824
59071
|
var { randomBytes: randomBytes7, createHash: createHash33 } = require("crypto");
|
|
58825
59072
|
var { Duplex, Readable: Readable2 } = require("stream");
|
|
58826
59073
|
var { URL: URL2 } = require("url");
|
|
58827
|
-
var
|
|
59074
|
+
var PerMessageDeflate2 = require_permessage_deflate();
|
|
58828
59075
|
var Receiver2 = require_receiver();
|
|
58829
59076
|
var Sender2 = require_sender();
|
|
58830
59077
|
var { isBlob } = require_validation();
|
|
58831
59078
|
var {
|
|
58832
59079
|
BINARY_TYPES,
|
|
59080
|
+
CLOSE_TIMEOUT,
|
|
58833
59081
|
EMPTY_BUFFER,
|
|
58834
59082
|
GUID,
|
|
58835
59083
|
kForOnEventAttribute,
|
|
@@ -58843,7 +59091,6 @@ var require_websocket = __commonJS({
|
|
|
58843
59091
|
} = require_event_target();
|
|
58844
59092
|
var { format, parse: parse7 } = require_extension();
|
|
58845
59093
|
var { toBuffer: toBuffer2 } = require_buffer_util();
|
|
58846
|
-
var closeTimeout = 30 * 1e3;
|
|
58847
59094
|
var kAborted = /* @__PURE__ */ Symbol("kAborted");
|
|
58848
59095
|
var protocolVersions = [8, 13];
|
|
58849
59096
|
var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
|
|
@@ -58889,6 +59136,7 @@ var require_websocket = __commonJS({
|
|
|
58889
59136
|
initAsClient(this, address, protocols, options);
|
|
58890
59137
|
} else {
|
|
58891
59138
|
this._autoPong = options.autoPong;
|
|
59139
|
+
this._closeTimeout = options.closeTimeout;
|
|
58892
59140
|
this._isServer = true;
|
|
58893
59141
|
}
|
|
58894
59142
|
}
|
|
@@ -58982,6 +59230,10 @@ var require_websocket = __commonJS({
|
|
|
58982
59230
|
* multiple times in the same tick
|
|
58983
59231
|
* @param {Function} [options.generateMask] The function used to generate the
|
|
58984
59232
|
* masking key
|
|
59233
|
+
* @param {Number} [options.maxBufferedChunks=0] The maximum number of
|
|
59234
|
+
* buffered data chunks
|
|
59235
|
+
* @param {Number} [options.maxFragments=0] The maximum number of message
|
|
59236
|
+
* fragments
|
|
58985
59237
|
* @param {Number} [options.maxPayload=0] The maximum allowed message size
|
|
58986
59238
|
* @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
|
|
58987
59239
|
* not to skip UTF-8 validation for text and close messages
|
|
@@ -58993,6 +59245,8 @@ var require_websocket = __commonJS({
|
|
|
58993
59245
|
binaryType: this.binaryType,
|
|
58994
59246
|
extensions: this._extensions,
|
|
58995
59247
|
isServer: this._isServer,
|
|
59248
|
+
maxBufferedChunks: options.maxBufferedChunks,
|
|
59249
|
+
maxFragments: options.maxFragments,
|
|
58996
59250
|
maxPayload: options.maxPayload,
|
|
58997
59251
|
skipUTF8Validation: options.skipUTF8Validation
|
|
58998
59252
|
});
|
|
@@ -59031,8 +59285,8 @@ var require_websocket = __commonJS({
|
|
|
59031
59285
|
this.emit("close", this._closeCode, this._closeMessage);
|
|
59032
59286
|
return;
|
|
59033
59287
|
}
|
|
59034
|
-
if (this._extensions[
|
|
59035
|
-
this._extensions[
|
|
59288
|
+
if (this._extensions[PerMessageDeflate2.extensionName]) {
|
|
59289
|
+
this._extensions[PerMessageDeflate2.extensionName].cleanup();
|
|
59036
59290
|
}
|
|
59037
59291
|
this._receiver.removeAllListeners();
|
|
59038
59292
|
this._readyState = _WebSocket.CLOSED;
|
|
@@ -59194,7 +59448,7 @@ var require_websocket = __commonJS({
|
|
|
59194
59448
|
fin: true,
|
|
59195
59449
|
...options
|
|
59196
59450
|
};
|
|
59197
|
-
if (!this._extensions[
|
|
59451
|
+
if (!this._extensions[PerMessageDeflate2.extensionName]) {
|
|
59198
59452
|
opts.compress = false;
|
|
59199
59453
|
}
|
|
59200
59454
|
this._sender.send(data || EMPTY_BUFFER, opts, cb);
|
|
@@ -59290,7 +59544,10 @@ var require_websocket = __commonJS({
|
|
|
59290
59544
|
const opts = {
|
|
59291
59545
|
allowSynchronousEvents: true,
|
|
59292
59546
|
autoPong: true,
|
|
59547
|
+
closeTimeout: CLOSE_TIMEOUT,
|
|
59293
59548
|
protocolVersion: protocolVersions[1],
|
|
59549
|
+
maxBufferedChunks: 256 * 1024,
|
|
59550
|
+
maxFragments: 16 * 1024,
|
|
59294
59551
|
maxPayload: 100 * 1024 * 1024,
|
|
59295
59552
|
skipUTF8Validation: false,
|
|
59296
59553
|
perMessageDeflate: true,
|
|
@@ -59307,6 +59564,7 @@ var require_websocket = __commonJS({
|
|
|
59307
59564
|
port: void 0
|
|
59308
59565
|
};
|
|
59309
59566
|
websocket._autoPong = opts.autoPong;
|
|
59567
|
+
websocket._closeTimeout = opts.closeTimeout;
|
|
59310
59568
|
if (!protocolVersions.includes(opts.protocolVersion)) {
|
|
59311
59569
|
throw new RangeError(
|
|
59312
59570
|
`Unsupported protocol version: ${opts.protocolVersion} (supported versions: ${protocolVersions.join(", ")})`
|
|
@@ -59318,7 +59576,7 @@ var require_websocket = __commonJS({
|
|
|
59318
59576
|
} else {
|
|
59319
59577
|
try {
|
|
59320
59578
|
parsedUrl = new URL2(address);
|
|
59321
|
-
} catch
|
|
59579
|
+
} catch {
|
|
59322
59580
|
throw new SyntaxError(`Invalid URL: ${address}`);
|
|
59323
59581
|
}
|
|
59324
59582
|
}
|
|
@@ -59366,13 +59624,13 @@ var require_websocket = __commonJS({
|
|
|
59366
59624
|
opts.path = parsedUrl.pathname + parsedUrl.search;
|
|
59367
59625
|
opts.timeout = opts.handshakeTimeout;
|
|
59368
59626
|
if (opts.perMessageDeflate) {
|
|
59369
|
-
perMessageDeflate = new
|
|
59370
|
-
opts.perMessageDeflate
|
|
59371
|
-
false,
|
|
59372
|
-
opts.maxPayload
|
|
59373
|
-
);
|
|
59627
|
+
perMessageDeflate = new PerMessageDeflate2({
|
|
59628
|
+
...opts.perMessageDeflate,
|
|
59629
|
+
isServer: false,
|
|
59630
|
+
maxPayload: opts.maxPayload
|
|
59631
|
+
});
|
|
59374
59632
|
opts.headers["Sec-WebSocket-Extensions"] = format({
|
|
59375
|
-
[
|
|
59633
|
+
[PerMessageDeflate2.extensionName]: perMessageDeflate.offer()
|
|
59376
59634
|
});
|
|
59377
59635
|
}
|
|
59378
59636
|
if (protocols.length) {
|
|
@@ -59515,23 +59773,25 @@ var require_websocket = __commonJS({
|
|
|
59515
59773
|
return;
|
|
59516
59774
|
}
|
|
59517
59775
|
const extensionNames = Object.keys(extensions);
|
|
59518
|
-
if (extensionNames.length !== 1 || extensionNames[0] !==
|
|
59776
|
+
if (extensionNames.length !== 1 || extensionNames[0] !== PerMessageDeflate2.extensionName) {
|
|
59519
59777
|
const message2 = "Server indicated an extension that was not requested";
|
|
59520
59778
|
abortHandshake(websocket, socket, message2);
|
|
59521
59779
|
return;
|
|
59522
59780
|
}
|
|
59523
59781
|
try {
|
|
59524
|
-
perMessageDeflate.accept(extensions[
|
|
59782
|
+
perMessageDeflate.accept(extensions[PerMessageDeflate2.extensionName]);
|
|
59525
59783
|
} catch (err) {
|
|
59526
59784
|
const message2 = "Invalid Sec-WebSocket-Extensions header";
|
|
59527
59785
|
abortHandshake(websocket, socket, message2);
|
|
59528
59786
|
return;
|
|
59529
59787
|
}
|
|
59530
|
-
websocket._extensions[
|
|
59788
|
+
websocket._extensions[PerMessageDeflate2.extensionName] = perMessageDeflate;
|
|
59531
59789
|
}
|
|
59532
59790
|
websocket.setSocket(socket, head, {
|
|
59533
59791
|
allowSynchronousEvents: opts.allowSynchronousEvents,
|
|
59534
59792
|
generateMask: opts.generateMask,
|
|
59793
|
+
maxBufferedChunks: opts.maxBufferedChunks,
|
|
59794
|
+
maxFragments: opts.maxFragments,
|
|
59535
59795
|
maxPayload: opts.maxPayload,
|
|
59536
59796
|
skipUTF8Validation: opts.skipUTF8Validation
|
|
59537
59797
|
});
|
|
@@ -59649,7 +59909,7 @@ var require_websocket = __commonJS({
|
|
|
59649
59909
|
function setCloseTimer(websocket) {
|
|
59650
59910
|
websocket._closeTimer = setTimeout(
|
|
59651
59911
|
websocket._socket.destroy.bind(websocket._socket),
|
|
59652
|
-
|
|
59912
|
+
websocket._closeTimeout
|
|
59653
59913
|
);
|
|
59654
59914
|
}
|
|
59655
59915
|
function socketOnClose() {
|
|
@@ -59658,8 +59918,8 @@ var require_websocket = __commonJS({
|
|
|
59658
59918
|
this.removeListener("data", socketOnData);
|
|
59659
59919
|
this.removeListener("end", socketOnEnd);
|
|
59660
59920
|
websocket._readyState = WebSocket2.CLOSING;
|
|
59661
|
-
|
|
59662
|
-
|
|
59921
|
+
if (!this._readableState.endEmitted && !websocket._closeFrameReceived && !websocket._receiver._writableState.errorEmitted && this._readableState.length !== 0) {
|
|
59922
|
+
const chunk = this.read(this._readableState.length);
|
|
59663
59923
|
websocket._receiver.write(chunk);
|
|
59664
59924
|
}
|
|
59665
59925
|
websocket._receiver.end();
|
|
@@ -59695,9 +59955,9 @@ var require_websocket = __commonJS({
|
|
|
59695
59955
|
}
|
|
59696
59956
|
});
|
|
59697
59957
|
|
|
59698
|
-
// ../../node_modules/
|
|
59958
|
+
// ../../node_modules/ws/lib/stream.js
|
|
59699
59959
|
var require_stream = __commonJS({
|
|
59700
|
-
"../../node_modules/
|
|
59960
|
+
"../../node_modules/ws/lib/stream.js"(exports2, module2) {
|
|
59701
59961
|
"use strict";
|
|
59702
59962
|
var WebSocket2 = require_websocket();
|
|
59703
59963
|
var { Duplex } = require("stream");
|
|
@@ -59793,9 +60053,9 @@ var require_stream = __commonJS({
|
|
|
59793
60053
|
}
|
|
59794
60054
|
});
|
|
59795
60055
|
|
|
59796
|
-
// ../../node_modules/
|
|
60056
|
+
// ../../node_modules/ws/lib/subprotocol.js
|
|
59797
60057
|
var require_subprotocol = __commonJS({
|
|
59798
|
-
"../../node_modules/
|
|
60058
|
+
"../../node_modules/ws/lib/subprotocol.js"(exports2, module2) {
|
|
59799
60059
|
"use strict";
|
|
59800
60060
|
var { tokenChars } = require_validation();
|
|
59801
60061
|
function parse7(header) {
|
|
@@ -59838,19 +60098,19 @@ var require_subprotocol = __commonJS({
|
|
|
59838
60098
|
}
|
|
59839
60099
|
});
|
|
59840
60100
|
|
|
59841
|
-
// ../../node_modules/
|
|
60101
|
+
// ../../node_modules/ws/lib/websocket-server.js
|
|
59842
60102
|
var require_websocket_server = __commonJS({
|
|
59843
|
-
"../../node_modules/
|
|
60103
|
+
"../../node_modules/ws/lib/websocket-server.js"(exports2, module2) {
|
|
59844
60104
|
"use strict";
|
|
59845
60105
|
var EventEmitter = require("events");
|
|
59846
60106
|
var http = require("http");
|
|
59847
60107
|
var { Duplex } = require("stream");
|
|
59848
60108
|
var { createHash: createHash33 } = require("crypto");
|
|
59849
|
-
var
|
|
59850
|
-
var
|
|
59851
|
-
var
|
|
60109
|
+
var extension2 = require_extension();
|
|
60110
|
+
var PerMessageDeflate2 = require_permessage_deflate();
|
|
60111
|
+
var subprotocol2 = require_subprotocol();
|
|
59852
60112
|
var WebSocket2 = require_websocket();
|
|
59853
|
-
var { GUID, kWebSocket } = require_constants2();
|
|
60113
|
+
var { CLOSE_TIMEOUT, GUID, kWebSocket } = require_constants2();
|
|
59854
60114
|
var keyRegex = /^[+/0-9A-Za-z]{22}==$/;
|
|
59855
60115
|
var RUNNING = 0;
|
|
59856
60116
|
var CLOSING = 1;
|
|
@@ -59869,8 +60129,15 @@ var require_websocket_server = __commonJS({
|
|
|
59869
60129
|
* pending connections
|
|
59870
60130
|
* @param {Boolean} [options.clientTracking=true] Specifies whether or not to
|
|
59871
60131
|
* track clients
|
|
60132
|
+
* @param {Number} [options.closeTimeout=30000] Duration in milliseconds to
|
|
60133
|
+
* wait for the closing handshake to finish after `websocket.close()` is
|
|
60134
|
+
* called
|
|
59872
60135
|
* @param {Function} [options.handleProtocols] A hook to handle protocols
|
|
59873
60136
|
* @param {String} [options.host] The hostname where to bind the server
|
|
60137
|
+
* @param {Number} [options.maxBufferedChunks=262144] The maximum number of
|
|
60138
|
+
* buffered data chunks
|
|
60139
|
+
* @param {Number} [options.maxFragments=16384] The maximum number of message
|
|
60140
|
+
* fragments
|
|
59874
60141
|
* @param {Number} [options.maxPayload=104857600] The maximum allowed message
|
|
59875
60142
|
* size
|
|
59876
60143
|
* @param {Boolean} [options.noServer=false] Enable no server mode
|
|
@@ -59892,11 +60159,14 @@ var require_websocket_server = __commonJS({
|
|
|
59892
60159
|
options = {
|
|
59893
60160
|
allowSynchronousEvents: true,
|
|
59894
60161
|
autoPong: true,
|
|
60162
|
+
maxBufferedChunks: 256 * 1024,
|
|
60163
|
+
maxFragments: 16 * 1024,
|
|
59895
60164
|
maxPayload: 100 * 1024 * 1024,
|
|
59896
60165
|
skipUTF8Validation: false,
|
|
59897
60166
|
perMessageDeflate: false,
|
|
59898
60167
|
handleProtocols: null,
|
|
59899
60168
|
clientTracking: true,
|
|
60169
|
+
closeTimeout: CLOSE_TIMEOUT,
|
|
59900
60170
|
verifyClient: null,
|
|
59901
60171
|
noServer: false,
|
|
59902
60172
|
backlog: null,
|
|
@@ -60067,7 +60337,7 @@ var require_websocket_server = __commonJS({
|
|
|
60067
60337
|
let protocols = /* @__PURE__ */ new Set();
|
|
60068
60338
|
if (secWebSocketProtocol !== void 0) {
|
|
60069
60339
|
try {
|
|
60070
|
-
protocols =
|
|
60340
|
+
protocols = subprotocol2.parse(secWebSocketProtocol);
|
|
60071
60341
|
} catch (err) {
|
|
60072
60342
|
const message2 = "Invalid Sec-WebSocket-Protocol header";
|
|
60073
60343
|
abortHandshakeOrEmitwsClientError(this, req, socket, 400, message2);
|
|
@@ -60077,16 +60347,16 @@ var require_websocket_server = __commonJS({
|
|
|
60077
60347
|
const secWebSocketExtensions = req.headers["sec-websocket-extensions"];
|
|
60078
60348
|
const extensions = {};
|
|
60079
60349
|
if (this.options.perMessageDeflate && secWebSocketExtensions !== void 0) {
|
|
60080
|
-
const perMessageDeflate = new
|
|
60081
|
-
this.options.perMessageDeflate,
|
|
60082
|
-
true,
|
|
60083
|
-
this.options.maxPayload
|
|
60084
|
-
);
|
|
60350
|
+
const perMessageDeflate = new PerMessageDeflate2({
|
|
60351
|
+
...this.options.perMessageDeflate,
|
|
60352
|
+
isServer: true,
|
|
60353
|
+
maxPayload: this.options.maxPayload
|
|
60354
|
+
});
|
|
60085
60355
|
try {
|
|
60086
|
-
const offers =
|
|
60087
|
-
if (offers[
|
|
60088
|
-
perMessageDeflate.accept(offers[
|
|
60089
|
-
extensions[
|
|
60356
|
+
const offers = extension2.parse(secWebSocketExtensions);
|
|
60357
|
+
if (offers[PerMessageDeflate2.extensionName]) {
|
|
60358
|
+
perMessageDeflate.accept(offers[PerMessageDeflate2.extensionName]);
|
|
60359
|
+
extensions[PerMessageDeflate2.extensionName] = perMessageDeflate;
|
|
60090
60360
|
}
|
|
60091
60361
|
} catch (err) {
|
|
60092
60362
|
const message2 = "Invalid or unacceptable Sec-WebSocket-Extensions header";
|
|
@@ -60157,10 +60427,10 @@ var require_websocket_server = __commonJS({
|
|
|
60157
60427
|
ws._protocol = protocol4;
|
|
60158
60428
|
}
|
|
60159
60429
|
}
|
|
60160
|
-
if (extensions[
|
|
60161
|
-
const params = extensions[
|
|
60162
|
-
const value2 =
|
|
60163
|
-
[
|
|
60430
|
+
if (extensions[PerMessageDeflate2.extensionName]) {
|
|
60431
|
+
const params = extensions[PerMessageDeflate2.extensionName].params;
|
|
60432
|
+
const value2 = extension2.format({
|
|
60433
|
+
[PerMessageDeflate2.extensionName]: [params]
|
|
60164
60434
|
});
|
|
60165
60435
|
headers.push(`Sec-WebSocket-Extensions: ${value2}`);
|
|
60166
60436
|
ws._extensions = extensions;
|
|
@@ -60170,6 +60440,8 @@ var require_websocket_server = __commonJS({
|
|
|
60170
60440
|
socket.removeListener("error", socketOnError);
|
|
60171
60441
|
ws.setSocket(socket, head, {
|
|
60172
60442
|
allowSynchronousEvents: this.options.allowSynchronousEvents,
|
|
60443
|
+
maxBufferedChunks: this.options.maxBufferedChunks,
|
|
60444
|
+
maxFragments: this.options.maxFragments,
|
|
60173
60445
|
maxPayload: this.options.maxPayload,
|
|
60174
60446
|
skipUTF8Validation: this.options.skipUTF8Validation
|
|
60175
60447
|
});
|
|
@@ -60233,7 +60505,7 @@ var import_node_worker_threads2 = require("worker_threads");
|
|
|
60233
60505
|
// package.json
|
|
60234
60506
|
var package_default = {
|
|
60235
60507
|
name: "@alan-ai-hq/agent-manager",
|
|
60236
|
-
version: "0.1.
|
|
60508
|
+
version: "0.1.176",
|
|
60237
60509
|
private: true,
|
|
60238
60510
|
type: "module",
|
|
60239
60511
|
description: "Alan machine runtime (alan-agent): identity, link, reconciler, session holders, run log, uploader, local API",
|
|
@@ -60275,11 +60547,12 @@ var package_default = {
|
|
|
60275
60547
|
"@types/node": "^22.20.5",
|
|
60276
60548
|
"engine.io-client": "6.6.4",
|
|
60277
60549
|
esbuild: "^0.28.2",
|
|
60278
|
-
"
|
|
60550
|
+
"oxc-parser": "^0.157.0",
|
|
60551
|
+
"smol-toml": "^1.9.1",
|
|
60279
60552
|
"socket.io": "^4.8.3",
|
|
60280
60553
|
"socket.io-client": "^4.8.3",
|
|
60281
60554
|
tsup: "^9.0.0",
|
|
60282
|
-
typescript: "
|
|
60555
|
+
typescript: "^7.0.2",
|
|
60283
60556
|
vitest: "^5.0.5",
|
|
60284
60557
|
zod: "4.6.7"
|
|
60285
60558
|
},
|
|
@@ -65657,10 +65930,10 @@ async function isRunnable(path4, platform3) {
|
|
|
65657
65930
|
}
|
|
65658
65931
|
}
|
|
65659
65932
|
function windowsExtensions(command, env) {
|
|
65660
|
-
const extensions = (envValue(env, "PATHEXT") || ".COM;.EXE;.BAT;.CMD").split(";").map((
|
|
65933
|
+
const extensions = (envValue(env, "PATHEXT") || ".COM;.EXE;.BAT;.CMD").split(";").map((extension2) => extension2.trim()).filter((extension2) => [".COM", ".EXE", ".BAT", ".CMD"].includes(extension2.toUpperCase()));
|
|
65661
65934
|
const named = command.toLowerCase();
|
|
65662
|
-
return [".com", ".exe", ...extensions.map((
|
|
65663
|
-
(
|
|
65935
|
+
return [".com", ".exe", ...extensions.map((extension2) => extension2.toLowerCase())].some(
|
|
65936
|
+
(extension2) => named.endsWith(extension2)
|
|
65664
65937
|
) ? [""] : extensions;
|
|
65665
65938
|
}
|
|
65666
65939
|
async function resolveCommandOnPath(command, env, platform3) {
|
|
@@ -65671,8 +65944,8 @@ async function resolveCommandOnPath(command, env, platform3) {
|
|
|
65671
65944
|
);
|
|
65672
65945
|
const extensions = platform3 === "win32" ? windowsExtensions(command, env) : [""];
|
|
65673
65946
|
for (const directory of directories) {
|
|
65674
|
-
for (const
|
|
65675
|
-
const candidate = (0, import_node_path42.join)(directory, `${command}${
|
|
65947
|
+
for (const extension2 of extensions) {
|
|
65948
|
+
const candidate = (0, import_node_path42.join)(directory, `${command}${extension2}`);
|
|
65676
65949
|
if (await isRunnable(candidate, platform3)) return candidate;
|
|
65677
65950
|
}
|
|
65678
65951
|
}
|
|
@@ -66387,11 +66660,11 @@ var import_node_path47 = require("path");
|
|
|
66387
66660
|
|
|
66388
66661
|
// ../../node_modules/smol-toml/dist/error.js
|
|
66389
66662
|
function getLineColFromPtr(string4, ptr) {
|
|
66390
|
-
let lines2 = string4.slice(0, ptr).split(/\r
|
|
66663
|
+
let lines2 = string4.slice(0, ptr).split(/\r?\n/);
|
|
66391
66664
|
return [lines2.length, lines2.pop().length + 1];
|
|
66392
66665
|
}
|
|
66393
66666
|
function makeCodeBlock(string4, line, column) {
|
|
66394
|
-
let lines2 = string4.split(/\r
|
|
66667
|
+
let lines2 = string4.split(/\r?\n/);
|
|
66395
66668
|
let codeblock = "";
|
|
66396
66669
|
let numberLen = (Math.log10(line + 1) | 0) + 1;
|
|
66397
66670
|
for (let i = line - 1; i <= line + 1; i++) {
|
|
@@ -66409,7 +66682,7 @@ function makeCodeBlock(string4, line, column) {
|
|
|
66409
66682
|
}
|
|
66410
66683
|
return codeblock;
|
|
66411
66684
|
}
|
|
66412
|
-
var TomlError = class extends Error {
|
|
66685
|
+
var TomlError = class _TomlError extends Error {
|
|
66413
66686
|
line;
|
|
66414
66687
|
column;
|
|
66415
66688
|
codeblock;
|
|
@@ -66423,116 +66696,165 @@ ${codeblock}`, options);
|
|
|
66423
66696
|
this.column = column;
|
|
66424
66697
|
this.codeblock = codeblock;
|
|
66425
66698
|
}
|
|
66699
|
+
/** @internal */
|
|
66700
|
+
static x(message2, ctx, ptr) {
|
|
66701
|
+
throw new _TomlError(message2, { toml: ctx.s, ptr: ptr ?? ctx.p });
|
|
66702
|
+
}
|
|
66426
66703
|
};
|
|
66427
66704
|
|
|
66428
|
-
// ../../node_modules/smol-toml/dist/
|
|
66429
|
-
function
|
|
66430
|
-
let
|
|
66431
|
-
|
|
66432
|
-
|
|
66433
|
-
|
|
66434
|
-
|
|
66435
|
-
|
|
66436
|
-
|
|
66437
|
-
|
|
66438
|
-
|
|
66439
|
-
|
|
66440
|
-
}
|
|
66441
|
-
function skipComment(str, ptr) {
|
|
66442
|
-
for (let i = ptr; i < str.length; i++) {
|
|
66443
|
-
let c = str[i];
|
|
66444
|
-
if (c === "\n")
|
|
66445
|
-
return i;
|
|
66446
|
-
if (c === "\r" && str[i + 1] === "\n")
|
|
66447
|
-
return i + 1;
|
|
66448
|
-
if (c < " " && c !== " " || c === "\x7F") {
|
|
66449
|
-
throw new TomlError("control characters are not allowed in comments", {
|
|
66450
|
-
toml: str,
|
|
66451
|
-
ptr
|
|
66452
|
-
});
|
|
66453
|
-
}
|
|
66454
|
-
}
|
|
66455
|
-
return str.length;
|
|
66456
|
-
}
|
|
66457
|
-
function skipVoid(str, ptr, banNewLines, banComments) {
|
|
66458
|
-
let c;
|
|
66459
|
-
while (1) {
|
|
66460
|
-
while ((c = str[ptr]) === " " || c === " " || !banNewLines && (c === "\n" || c === "\r" && str[ptr + 1] === "\n"))
|
|
66461
|
-
ptr++;
|
|
66462
|
-
if (banComments || c !== "#")
|
|
66463
|
-
break;
|
|
66464
|
-
ptr = skipComment(str, ptr);
|
|
66465
|
-
}
|
|
66466
|
-
return ptr;
|
|
66467
|
-
}
|
|
66468
|
-
function skipUntil(str, ptr, sep4, end, banNewLines = false) {
|
|
66469
|
-
if (!end) {
|
|
66470
|
-
ptr = indexOfNewline(str, ptr);
|
|
66471
|
-
return ptr < 0 ? str.length : ptr;
|
|
66472
|
-
}
|
|
66473
|
-
for (let i = ptr; i < str.length; i++) {
|
|
66474
|
-
let c = str[i];
|
|
66475
|
-
if (c === "#") {
|
|
66476
|
-
i = indexOfNewline(str, i);
|
|
66477
|
-
} else if (c === sep4) {
|
|
66478
|
-
return i + 1;
|
|
66479
|
-
} else if (c === end || banNewLines && (c === "\n" || c === "\r" && str[i + 1] === "\n")) {
|
|
66480
|
-
return i;
|
|
66481
|
-
}
|
|
66705
|
+
// ../../node_modules/smol-toml/dist/primitive.js
|
|
66706
|
+
function parseString(ctx) {
|
|
66707
|
+
let startPtr = ctx.p;
|
|
66708
|
+
let c = ctx.s.charCodeAt(ctx.p++);
|
|
66709
|
+
let first = c;
|
|
66710
|
+
let isLiteral = c === 39;
|
|
66711
|
+
let isMultiline = c === ctx.s.charCodeAt(ctx.p) && c === ctx.s.charCodeAt(ctx.p + 1);
|
|
66712
|
+
if (isMultiline) {
|
|
66713
|
+
if ((c = ctx.s.charCodeAt(ctx.p += 2)) === 10)
|
|
66714
|
+
ctx.p++;
|
|
66715
|
+
else if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)
|
|
66716
|
+
ctx.p += 2;
|
|
66482
66717
|
}
|
|
66483
|
-
|
|
66484
|
-
|
|
66485
|
-
|
|
66486
|
-
|
|
66487
|
-
|
|
66488
|
-
|
|
66489
|
-
|
|
66490
|
-
|
|
66491
|
-
|
|
66492
|
-
|
|
66493
|
-
|
|
66494
|
-
|
|
66495
|
-
|
|
66496
|
-
|
|
66497
|
-
|
|
66498
|
-
|
|
66499
|
-
|
|
66500
|
-
|
|
66501
|
-
|
|
66718
|
+
let parsed = "";
|
|
66719
|
+
let sliceStart = ctx.p;
|
|
66720
|
+
let state = 0;
|
|
66721
|
+
for (; ctx.p < ctx.s.length; ctx.p++) {
|
|
66722
|
+
c = ctx.s.charCodeAt(ctx.p);
|
|
66723
|
+
if (isMultiline && (c === 10 || c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)) {
|
|
66724
|
+
state = state && 3;
|
|
66725
|
+
} else if (c < 32 && c !== 9 || c === 127) {
|
|
66726
|
+
TomlError.x("control characters are not allowed in strings", ctx);
|
|
66727
|
+
} else if ((!state || state === 3) && c === first && (!isMultiline || ctx.s.charCodeAt(ctx.p + 1) === first && ctx.s.charCodeAt(ctx.p + 2) === first)) {
|
|
66728
|
+
if (isMultiline) {
|
|
66729
|
+
if (ctx.s.charCodeAt(ctx.p + 3) === first)
|
|
66730
|
+
ctx.p++;
|
|
66731
|
+
if (ctx.s.charCodeAt(ctx.p + 3) === first)
|
|
66732
|
+
ctx.p++;
|
|
66733
|
+
}
|
|
66734
|
+
if (!state) {
|
|
66735
|
+
let s = ctx.s.slice(sliceStart, ctx.p);
|
|
66736
|
+
parsed = parsed ? parsed + s : s;
|
|
66737
|
+
}
|
|
66738
|
+
ctx.p += isMultiline ? 3 : 1;
|
|
66739
|
+
return parsed;
|
|
66740
|
+
} else if (!state) {
|
|
66741
|
+
if (!isLiteral && c === 92) {
|
|
66742
|
+
parsed += ctx.s.slice(sliceStart, sliceStart = ctx.p);
|
|
66743
|
+
state = 1;
|
|
66744
|
+
}
|
|
66745
|
+
} else if (state === 1) {
|
|
66746
|
+
if (c === 120 || c === 117 || c === 85) {
|
|
66747
|
+
let errPtr = ctx.p++ - 1;
|
|
66748
|
+
let value2 = 0;
|
|
66749
|
+
let len = c === 120 ? 2 : c === 117 ? 4 : 8;
|
|
66750
|
+
for (let j = 0; j < len; j++, ctx.p++) {
|
|
66751
|
+
let hex3 = ctx.s.charCodeAt(ctx.p);
|
|
66752
|
+
let digit = (
|
|
66753
|
+
/* 0-9 */
|
|
66754
|
+
hex3 >= 48 && hex3 <= 57 ? hex3 - 48 : (
|
|
66755
|
+
/* A-F */
|
|
66756
|
+
hex3 >= 65 && hex3 <= 70 ? hex3 - 65 + 10 : (
|
|
66757
|
+
/* a-f */
|
|
66758
|
+
hex3 >= 97 && hex3 <= 102 ? hex3 - 97 + 10 : -1
|
|
66759
|
+
)
|
|
66760
|
+
)
|
|
66761
|
+
);
|
|
66762
|
+
if (digit < 0)
|
|
66763
|
+
TomlError.x("invalid non-hex character in unicode escape", ctx);
|
|
66764
|
+
value2 = value2 << 4 | digit;
|
|
66765
|
+
}
|
|
66766
|
+
if (value2 < 0 || value2 > 1114111 || value2 >= 55296 && value2 <= 57343) {
|
|
66767
|
+
TomlError.x("invalid unicode escape", ctx, errPtr);
|
|
66768
|
+
}
|
|
66769
|
+
parsed += String.fromCodePoint(value2);
|
|
66770
|
+
sliceStart = ctx.p--;
|
|
66771
|
+
state = 0;
|
|
66772
|
+
} else if (isMultiline && (c === 32 || c === 9)) {
|
|
66773
|
+
state = 2;
|
|
66774
|
+
} else {
|
|
66775
|
+
if (c === 98)
|
|
66776
|
+
parsed += "\b";
|
|
66777
|
+
else if (c === 116)
|
|
66778
|
+
parsed += " ";
|
|
66779
|
+
else if (c === 110)
|
|
66780
|
+
parsed += "\n";
|
|
66781
|
+
else if (c === 102)
|
|
66782
|
+
parsed += "\f";
|
|
66783
|
+
else if (c === 114)
|
|
66784
|
+
parsed += "\r";
|
|
66785
|
+
else if (c === 101)
|
|
66786
|
+
parsed += "\x1B";
|
|
66787
|
+
else if (c === 34)
|
|
66788
|
+
parsed += '"';
|
|
66789
|
+
else if (c === 92)
|
|
66790
|
+
parsed += "\\";
|
|
66791
|
+
else
|
|
66792
|
+
TomlError.x("unrecognised escape sequence", ctx);
|
|
66793
|
+
sliceStart = ctx.p + 1;
|
|
66794
|
+
state = 0;
|
|
66795
|
+
}
|
|
66796
|
+
} else if (c !== 32 && c !== 9) {
|
|
66797
|
+
if (state === 2)
|
|
66798
|
+
TomlError.x("invalid escape: only line-ending whitespace may be escaped", ctx, sliceStart);
|
|
66799
|
+
state = !isLiteral && c === 92 ? 1 : 0;
|
|
66800
|
+
sliceStart = ctx.p;
|
|
66502
66801
|
}
|
|
66503
66802
|
}
|
|
66504
|
-
|
|
66803
|
+
TomlError.x("unfinished string", ctx, startPtr);
|
|
66505
66804
|
}
|
|
66506
66805
|
|
|
66507
66806
|
// ../../node_modules/smol-toml/dist/date.js
|
|
66508
|
-
var DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[
|
|
66807
|
+
var DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[Tt ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|z|[-+]\d{2}:\d{2})?$/i;
|
|
66509
66808
|
var TomlDate = class _TomlDate extends Date {
|
|
66510
66809
|
#hasDate = false;
|
|
66511
66810
|
#hasTime = false;
|
|
66512
66811
|
#offset = null;
|
|
66513
|
-
constructor(date5) {
|
|
66812
|
+
constructor(date5, fasttype, unsafeDelim) {
|
|
66514
66813
|
let hasDate = true;
|
|
66515
66814
|
let hasTime = true;
|
|
66516
66815
|
let offset = "Z";
|
|
66816
|
+
let c;
|
|
66517
66817
|
if (typeof date5 === "string") {
|
|
66518
|
-
|
|
66519
|
-
|
|
66520
|
-
|
|
66521
|
-
|
|
66522
|
-
|
|
66523
|
-
|
|
66524
|
-
|
|
66525
|
-
|
|
66526
|
-
|
|
66527
|
-
|
|
66818
|
+
if (fasttype)
|
|
66819
|
+
prep: {
|
|
66820
|
+
if (fasttype < 3) {
|
|
66821
|
+
if (+date5.slice(11, 13) > 23) {
|
|
66822
|
+
date5 = "";
|
|
66823
|
+
break prep;
|
|
66824
|
+
}
|
|
66825
|
+
if (fasttype === 2) {
|
|
66826
|
+
offset = null;
|
|
66827
|
+
date5 += "Z";
|
|
66828
|
+
} else if ((c = date5.charCodeAt(date5.length - 1)) !== 90 && c !== 122) {
|
|
66829
|
+
offset = date5.slice(date5.length - 6);
|
|
66830
|
+
}
|
|
66831
|
+
if (unsafeDelim)
|
|
66832
|
+
date5 = date5.slice(0, 10) + "T" + date5.slice(11);
|
|
66833
|
+
} else if (fasttype === 4) {
|
|
66834
|
+
date5 = +date5.slice(0, 2) > 23 ? "" : `0000-01-01T${date5}Z`;
|
|
66835
|
+
}
|
|
66836
|
+
hasDate = fasttype !== 4;
|
|
66837
|
+
hasTime = fasttype !== 3;
|
|
66838
|
+
}
|
|
66839
|
+
else {
|
|
66840
|
+
let match = date5.match(DATE_TIME_RE);
|
|
66841
|
+
if (match) {
|
|
66842
|
+
if (!match[1]) {
|
|
66843
|
+
hasDate = false;
|
|
66844
|
+
date5 = `0000-01-01T${date5}`;
|
|
66845
|
+
}
|
|
66846
|
+
hasTime = !!match[2];
|
|
66847
|
+
hasTime && date5[10] === " " && (date5 = date5.replace(" ", "T"));
|
|
66848
|
+
if (match[2] && +match[2] > 23) {
|
|
66849
|
+
date5 = "";
|
|
66850
|
+
} else {
|
|
66851
|
+
offset = match[3] || null;
|
|
66852
|
+
if (!offset && hasTime)
|
|
66853
|
+
date5 += "Z";
|
|
66854
|
+
}
|
|
66528
66855
|
} else {
|
|
66529
|
-
|
|
66530
|
-
date5 = date5.toUpperCase();
|
|
66531
|
-
if (!offset && hasTime)
|
|
66532
|
-
date5 += "Z";
|
|
66856
|
+
date5 = "";
|
|
66533
66857
|
}
|
|
66534
|
-
} else {
|
|
66535
|
-
date5 = "";
|
|
66536
66858
|
}
|
|
66537
66859
|
}
|
|
66538
66860
|
super(date5);
|
|
@@ -66565,7 +66887,7 @@ var TomlDate = class _TomlDate extends Date {
|
|
|
66565
66887
|
return iso.slice(11, 23);
|
|
66566
66888
|
if (this.#offset === null)
|
|
66567
66889
|
return iso.slice(0, -1);
|
|
66568
|
-
if (this.#offset === "Z")
|
|
66890
|
+
if (this.#offset === "Z" || this.#offset === "z")
|
|
66569
66891
|
return iso;
|
|
66570
66892
|
let offset = +this.#offset.slice(1, 3) * 60 + +this.#offset.slice(4, 6);
|
|
66571
66893
|
offset = this.#offset[0] === "-" ? offset : -offset;
|
|
@@ -66596,362 +66918,360 @@ var TomlDate = class _TomlDate extends Date {
|
|
|
66596
66918
|
}
|
|
66597
66919
|
};
|
|
66598
66920
|
|
|
66599
|
-
// ../../node_modules/smol-toml/dist/
|
|
66600
|
-
|
|
66601
|
-
|
|
66602
|
-
|
|
66603
|
-
|
|
66604
|
-
|
|
66605
|
-
|
|
66606
|
-
|
|
66607
|
-
|
|
66608
|
-
|
|
66609
|
-
|
|
66610
|
-
|
|
66611
|
-
|
|
66612
|
-
|
|
66613
|
-
|
|
66614
|
-
|
|
66615
|
-
|
|
66616
|
-
let isMultiline = str[ptr++] === str[ptr] && str[ptr] === str[ptr + 1];
|
|
66617
|
-
if (isMultiline) {
|
|
66618
|
-
endPtr -= 2;
|
|
66619
|
-
if (str[ptr += 2] === "\r")
|
|
66620
|
-
ptr++;
|
|
66621
|
-
if (str[ptr] === "\n")
|
|
66622
|
-
ptr++;
|
|
66623
|
-
}
|
|
66624
|
-
let tmp = 0;
|
|
66625
|
-
let isEscape;
|
|
66626
|
-
let parsed = "";
|
|
66627
|
-
let sliceStart = ptr;
|
|
66628
|
-
while (ptr < endPtr - 1) {
|
|
66629
|
-
let c = str[ptr++];
|
|
66630
|
-
if (c === "\n" || c === "\r" && str[ptr] === "\n") {
|
|
66631
|
-
if (!isMultiline) {
|
|
66632
|
-
throw new TomlError("newlines are not allowed in strings", {
|
|
66633
|
-
toml: str,
|
|
66634
|
-
ptr: ptr - 1
|
|
66635
|
-
});
|
|
66636
|
-
}
|
|
66637
|
-
} else if (c < " " && c !== " " || c === "\x7F") {
|
|
66638
|
-
throw new TomlError("control characters are not allowed in strings", {
|
|
66639
|
-
toml: str,
|
|
66640
|
-
ptr: ptr - 1
|
|
66641
|
-
});
|
|
66642
|
-
}
|
|
66643
|
-
if (isEscape) {
|
|
66644
|
-
isEscape = false;
|
|
66645
|
-
if (c === "x" || c === "u" || c === "U") {
|
|
66646
|
-
let code = str.slice(ptr, ptr += c === "x" ? 2 : c === "u" ? 4 : 8);
|
|
66647
|
-
if (!ESCAPE_REGEX.test(code)) {
|
|
66648
|
-
throw new TomlError("invalid unicode escape", {
|
|
66649
|
-
toml: str,
|
|
66650
|
-
ptr: tmp
|
|
66651
|
-
});
|
|
66652
|
-
}
|
|
66653
|
-
try {
|
|
66654
|
-
parsed += String.fromCodePoint(parseInt(code, 16));
|
|
66655
|
-
} catch {
|
|
66656
|
-
throw new TomlError("invalid unicode escape", {
|
|
66657
|
-
toml: str,
|
|
66658
|
-
ptr: tmp
|
|
66659
|
-
});
|
|
66660
|
-
}
|
|
66661
|
-
} else if (isMultiline && (c === "\n" || c === " " || c === " " || c === "\r")) {
|
|
66662
|
-
ptr = skipVoid(str, ptr - 1, true);
|
|
66663
|
-
if (str[ptr] !== "\n" && str[ptr] !== "\r") {
|
|
66664
|
-
throw new TomlError("invalid escape: only line-ending whitespace may be escaped", {
|
|
66665
|
-
toml: str,
|
|
66666
|
-
ptr: tmp
|
|
66667
|
-
});
|
|
66668
|
-
}
|
|
66669
|
-
ptr = skipVoid(str, ptr);
|
|
66670
|
-
} else if (c in ESC_MAP) {
|
|
66671
|
-
parsed += ESC_MAP[c];
|
|
66672
|
-
} else {
|
|
66673
|
-
throw new TomlError("unrecognized escape sequence", {
|
|
66674
|
-
toml: str,
|
|
66675
|
-
ptr: tmp
|
|
66676
|
-
});
|
|
66677
|
-
}
|
|
66678
|
-
sliceStart = ptr;
|
|
66679
|
-
} else if (!isLiteral && c === "\\") {
|
|
66680
|
-
tmp = ptr - 1;
|
|
66681
|
-
isEscape = true;
|
|
66682
|
-
parsed += str.slice(sliceStart, tmp);
|
|
66683
|
-
}
|
|
66921
|
+
// ../../node_modules/smol-toml/dist/extract.js
|
|
66922
|
+
function isDigit(char, base = 10) {
|
|
66923
|
+
return base === 16 ? char > 47 && char < 58 || char > 64 && char < 71 || char > 96 && char < 103 : char > 47 && char < 48 + base;
|
|
66924
|
+
}
|
|
66925
|
+
function isEndOfValue(char, delim) {
|
|
66926
|
+
return char === 32 || char === 9 || char === 10 || char === 13 || // Structure end or next value delimiter
|
|
66927
|
+
delim && (char === delim || char === 44) || // Comment
|
|
66928
|
+
char === 35;
|
|
66929
|
+
}
|
|
66930
|
+
function extractValue(ctx, end) {
|
|
66931
|
+
let errPtr = ctx.p;
|
|
66932
|
+
let c = ctx.s.charCodeAt(ctx.p);
|
|
66933
|
+
if (c === 91 || c === 123) {
|
|
66934
|
+
ctx.d-- || TomlError.x("document contains excessively nested structures. aborting.", ctx);
|
|
66935
|
+
let value2 = c === 91 ? parseArray(ctx) : parseInlineTable(ctx);
|
|
66936
|
+
ctx.d++;
|
|
66937
|
+
return value2;
|
|
66684
66938
|
}
|
|
66685
|
-
|
|
66686
|
-
|
|
66687
|
-
function parseValue(value2, toml, ptr, integersAsBigInt) {
|
|
66688
|
-
if (value2 === "true")
|
|
66689
|
-
return true;
|
|
66690
|
-
if (value2 === "false")
|
|
66691
|
-
return false;
|
|
66692
|
-
if (value2 === "-inf")
|
|
66693
|
-
return -Infinity;
|
|
66694
|
-
if (value2 === "inf" || value2 === "+inf")
|
|
66695
|
-
return Infinity;
|
|
66696
|
-
if (value2 === "nan" || value2 === "+nan" || value2 === "-nan")
|
|
66697
|
-
return NaN;
|
|
66698
|
-
if (value2 === "-0")
|
|
66699
|
-
return integersAsBigInt ? 0n : 0;
|
|
66700
|
-
let isInt = INT_REGEX.test(value2);
|
|
66701
|
-
if (isInt || FLOAT_REGEX.test(value2)) {
|
|
66702
|
-
if (LEADING_ZERO.test(value2)) {
|
|
66703
|
-
throw new TomlError("leading zeroes are not allowed", {
|
|
66704
|
-
toml,
|
|
66705
|
-
ptr
|
|
66706
|
-
});
|
|
66707
|
-
}
|
|
66708
|
-
value2 = value2.replace(/_/g, "");
|
|
66709
|
-
let numeric = +value2;
|
|
66710
|
-
if (isNaN(numeric)) {
|
|
66711
|
-
throw new TomlError("invalid number", {
|
|
66712
|
-
toml,
|
|
66713
|
-
ptr
|
|
66714
|
-
});
|
|
66715
|
-
}
|
|
66716
|
-
if (isInt) {
|
|
66717
|
-
if ((isInt = !Number.isSafeInteger(numeric)) && !integersAsBigInt) {
|
|
66718
|
-
throw new TomlError("integer value cannot be represented losslessly", {
|
|
66719
|
-
toml,
|
|
66720
|
-
ptr
|
|
66721
|
-
});
|
|
66722
|
-
}
|
|
66723
|
-
if (isInt || integersAsBigInt === true)
|
|
66724
|
-
numeric = BigInt(value2);
|
|
66725
|
-
}
|
|
66726
|
-
return numeric;
|
|
66939
|
+
if (c === 34 || c === 39) {
|
|
66940
|
+
return parseString(ctx);
|
|
66727
66941
|
}
|
|
66728
|
-
|
|
66729
|
-
|
|
66730
|
-
|
|
66731
|
-
|
|
66732
|
-
ptr
|
|
66733
|
-
});
|
|
66942
|
+
if (c === 116) {
|
|
66943
|
+
if (ctx.s.charCodeAt(++ctx.p) !== 114 || ctx.s.charCodeAt(++ctx.p) !== 117 || ctx.s.charCodeAt(++ctx.p) !== 101)
|
|
66944
|
+
TomlError.x("invalid value", ctx, errPtr);
|
|
66945
|
+
return ctx.p++, true;
|
|
66734
66946
|
}
|
|
66735
|
-
|
|
66736
|
-
|
|
66737
|
-
|
|
66738
|
-
|
|
66739
|
-
function sliceAndTrimEndOf(str, startPtr, endPtr) {
|
|
66740
|
-
let value2 = str.slice(startPtr, endPtr);
|
|
66741
|
-
let commentIdx = value2.indexOf("#");
|
|
66742
|
-
if (commentIdx > -1) {
|
|
66743
|
-
skipComment(str, commentIdx);
|
|
66744
|
-
value2 = value2.slice(0, commentIdx);
|
|
66947
|
+
if (c === 102) {
|
|
66948
|
+
if (ctx.s.charCodeAt(++ctx.p) !== 97 || ctx.s.charCodeAt(++ctx.p) !== 108 || ctx.s.charCodeAt(++ctx.p) !== 115 || ctx.s.charCodeAt(++ctx.p) !== 101)
|
|
66949
|
+
TomlError.x("invalid value", ctx, errPtr);
|
|
66950
|
+
return ctx.p++, false;
|
|
66745
66951
|
}
|
|
66746
|
-
|
|
66747
|
-
|
|
66748
|
-
function extractValue(str, ptr, end, depth, integersAsBigInt) {
|
|
66749
|
-
if (depth === 0) {
|
|
66750
|
-
throw new TomlError("document contains excessively nested structures. aborting.", {
|
|
66751
|
-
toml: str,
|
|
66752
|
-
ptr
|
|
66753
|
-
});
|
|
66952
|
+
if (c === 43 || c === 45) {
|
|
66953
|
+
return parseNumber(ctx, ctx.p, ctx.s.charCodeAt(++ctx.p), 44 - c, end);
|
|
66754
66954
|
}
|
|
66755
|
-
|
|
66756
|
-
|
|
66757
|
-
|
|
66758
|
-
|
|
66759
|
-
|
|
66760
|
-
|
|
66761
|
-
|
|
66762
|
-
|
|
66763
|
-
|
|
66764
|
-
|
|
66765
|
-
|
|
66766
|
-
|
|
66955
|
+
if (ctx.s.charCodeAt(ctx.p + 4) === 45 && ctx.s.charCodeAt(ctx.p + 7) === 45) {
|
|
66956
|
+
return parseDate(ctx, c, end);
|
|
66957
|
+
}
|
|
66958
|
+
if (ctx.s.charCodeAt(ctx.p + 2) === 58) {
|
|
66959
|
+
return parseTime(ctx, c, end);
|
|
66960
|
+
}
|
|
66961
|
+
return parseNumber(ctx, ctx.p, c, 0, end);
|
|
66962
|
+
}
|
|
66963
|
+
function parseNumber(ctx, startPtr, startChr, sign, endChr) {
|
|
66964
|
+
let c = startChr;
|
|
66965
|
+
let state = 0;
|
|
66966
|
+
let hasUnderscores = false;
|
|
66967
|
+
if (c === 105) {
|
|
66968
|
+
if (ctx.s.charCodeAt(++ctx.p) !== 110 || ctx.s.charCodeAt(++ctx.p) !== 102)
|
|
66969
|
+
TomlError.x("invalid value", ctx, startPtr);
|
|
66970
|
+
return ctx.p++, (sign || 1) / 0;
|
|
66971
|
+
}
|
|
66972
|
+
if (c === 110) {
|
|
66973
|
+
if (ctx.s.charCodeAt(++ctx.p) !== 97 || ctx.s.charCodeAt(++ctx.p) !== 110)
|
|
66974
|
+
TomlError.x("invalid value", ctx, startPtr);
|
|
66975
|
+
return ctx.p++, NaN;
|
|
66976
|
+
}
|
|
66977
|
+
if (c === 48) {
|
|
66978
|
+
if (++ctx.p >= ctx.s.length || isEndOfValue(c = ctx.s.charCodeAt(ctx.p), endChr))
|
|
66979
|
+
return ctx.bi === true ? 0n : 0;
|
|
66980
|
+
if (!sign) {
|
|
66981
|
+
if (c === 120)
|
|
66982
|
+
return parseIntegerBaseN(ctx, startPtr, 16, endChr);
|
|
66983
|
+
else if (c === 98)
|
|
66984
|
+
return parseIntegerBaseN(ctx, startPtr, 2, endChr);
|
|
66985
|
+
else if (c === 111)
|
|
66986
|
+
return parseIntegerBaseN(ctx, startPtr, 8, endChr);
|
|
66987
|
+
}
|
|
66988
|
+
if (c === 46)
|
|
66989
|
+
state = 2;
|
|
66990
|
+
else if (c === 101 || c === 69)
|
|
66991
|
+
state = 4;
|
|
66992
|
+
else
|
|
66993
|
+
TomlError.x("illegal leading zero", ctx, startPtr);
|
|
66994
|
+
} else if (!isDigit(c))
|
|
66995
|
+
TomlError.x("invalid value", ctx, startPtr);
|
|
66996
|
+
while (++ctx.p < ctx.s.length && (c = ctx.s.charCodeAt(ctx.p), !isEndOfValue(c, endChr))) {
|
|
66997
|
+
if (!state)
|
|
66998
|
+
state = 1;
|
|
66999
|
+
if (c === 95) {
|
|
67000
|
+
if (!(state & 1))
|
|
67001
|
+
TomlError.x("illegal underscore", ctx);
|
|
67002
|
+
state += 11;
|
|
67003
|
+
hasUnderscores = true;
|
|
67004
|
+
} else if (state === 1 && c === 46)
|
|
67005
|
+
state = 2;
|
|
67006
|
+
else if ((state === 1 || state === 3) && (c === 101 || c === 69))
|
|
67007
|
+
state = 4;
|
|
67008
|
+
else if (state === 4 && (c === 43 || c === 45)) {
|
|
67009
|
+
state = 6;
|
|
67010
|
+
} else if (!isDigit(c))
|
|
67011
|
+
TomlError.x(`illegal character in numeric literal`, ctx);
|
|
67012
|
+
else if (state > 9)
|
|
67013
|
+
state -= 11;
|
|
67014
|
+
else if (!(state & 1))
|
|
67015
|
+
state++;
|
|
67016
|
+
}
|
|
67017
|
+
if (!state) {
|
|
67018
|
+
let val = (startChr - 48) * (sign || 1);
|
|
67019
|
+
return ctx.bi === true ? BigInt(val) : val;
|
|
67020
|
+
}
|
|
67021
|
+
if (!(state & 1))
|
|
67022
|
+
TomlError.x("unfinished numeric value", ctx, startPtr);
|
|
67023
|
+
let str = ctx.s.slice(startPtr, ctx.p);
|
|
67024
|
+
if (hasUnderscores)
|
|
67025
|
+
str = str.replaceAll("_", "");
|
|
67026
|
+
return state > 1 ? parseFloat(str) : parseInteger(ctx, str, 10, startPtr);
|
|
67027
|
+
}
|
|
67028
|
+
function parseIntegerBaseN(ctx, startPtr, base, endChr) {
|
|
67029
|
+
let c, underscore = 1;
|
|
67030
|
+
while (++ctx.p < ctx.s.length && (c = ctx.s.charCodeAt(ctx.p), !isEndOfValue(c, endChr))) {
|
|
67031
|
+
if (c === 95) {
|
|
67032
|
+
if (underscore & 1)
|
|
67033
|
+
TomlError.x("illegal underscore", ctx);
|
|
67034
|
+
underscore = 3;
|
|
67035
|
+
} else if (!isDigit(c, base))
|
|
67036
|
+
TomlError.x(`illegal character in numeric literal`, ctx);
|
|
67037
|
+
else if (underscore & 1)
|
|
67038
|
+
underscore--;
|
|
67039
|
+
}
|
|
67040
|
+
if (underscore & 1)
|
|
67041
|
+
TomlError.x("unfinished numeric value", ctx);
|
|
67042
|
+
let str = ctx.s.slice(startPtr + 2, ctx.p);
|
|
67043
|
+
if (underscore)
|
|
67044
|
+
str = str.replaceAll("_", "");
|
|
67045
|
+
return parseInteger(ctx, str, base, startPtr);
|
|
67046
|
+
}
|
|
67047
|
+
function parseInteger(ctx, str, base, startPtr) {
|
|
67048
|
+
if (ctx.bi !== true)
|
|
67049
|
+
int: {
|
|
67050
|
+
let val = parseInt(str, base);
|
|
67051
|
+
if (!Number.isSafeInteger(val)) {
|
|
67052
|
+
if (ctx.bi)
|
|
67053
|
+
break int;
|
|
67054
|
+
TomlError.x("integer value cannot be represented losslessly", ctx, startPtr);
|
|
66767
67055
|
}
|
|
67056
|
+
return val;
|
|
66768
67057
|
}
|
|
66769
|
-
|
|
67058
|
+
return base === 10 ? BigInt(str) : BigInt((base === 2 ? "0b" : base === 8 ? "0o" : "0x") + str);
|
|
67059
|
+
}
|
|
67060
|
+
function parseDate(ctx, c, endChr) {
|
|
67061
|
+
let startPtr = ctx.p++, unsafeSeparator;
|
|
67062
|
+
if (!isDigit(c) || !isDigit(ctx.s.charCodeAt(ctx.p++)) || !isDigit(ctx.s.charCodeAt(ctx.p++)) || !isDigit(ctx.s.charCodeAt(ctx.p++))) {
|
|
67063
|
+
return parseNumber(ctx, ctx.p = startPtr, c, 0, endChr);
|
|
67064
|
+
}
|
|
67065
|
+
ctx.p += 5;
|
|
67066
|
+
if (!isDigit(ctx.s.charCodeAt(ctx.p++)))
|
|
67067
|
+
TomlError.x("invalid date-time: date part is malformed", ctx, startPtr);
|
|
67068
|
+
if (ctx.p >= ctx.s.length || ((c = ctx.s.charCodeAt(ctx.p)) !== 32 || (unsafeSeparator = true, !isDigit(ctx.s.charCodeAt(ctx.p + 1)))) && c !== 84 && c !== 116) {
|
|
67069
|
+
let t2 = ctx.s.slice(startPtr, ctx.p);
|
|
67070
|
+
return readDate(ctx, t2, 3, false, startPtr);
|
|
67071
|
+
}
|
|
67072
|
+
if (ctx.s.charCodeAt(ctx.p += 3) !== 58)
|
|
67073
|
+
TomlError.x("invalid date-time: time part is malformed", ctx, startPtr);
|
|
67074
|
+
if (ctx.s.charCodeAt(ctx.p += 3) === 58)
|
|
67075
|
+
ctx.p += 3;
|
|
67076
|
+
if (ctx.s.charCodeAt(ctx.p) === 46)
|
|
67077
|
+
while (isDigit(ctx.s.charCodeAt(++ctx.p)))
|
|
67078
|
+
;
|
|
67079
|
+
if (c = ctx.s.charCodeAt(ctx.p)) {
|
|
67080
|
+
if (c === 90 || c === 122) {
|
|
67081
|
+
let t2 = ctx.s.slice(startPtr, ++ctx.p);
|
|
67082
|
+
return readDate(ctx, t2, 1, unsafeSeparator, startPtr, "[+00:00]");
|
|
67083
|
+
}
|
|
67084
|
+
if (c === 43 || c === 45) {
|
|
67085
|
+
let t2 = ctx.s.slice(startPtr, ctx.p += 6);
|
|
67086
|
+
return readDate(ctx, t2, 1, unsafeSeparator, startPtr, !ctx.ld && "[" + ctx.s.slice(ctx.p - 6, ctx.p) + "]");
|
|
67087
|
+
}
|
|
67088
|
+
}
|
|
67089
|
+
let t = ctx.s.slice(startPtr, ctx.p);
|
|
67090
|
+
return readDate(ctx, t, 2, unsafeSeparator, startPtr);
|
|
67091
|
+
}
|
|
67092
|
+
function parseTime(ctx, c, endChr) {
|
|
67093
|
+
let start2 = ctx.p;
|
|
67094
|
+
if (!isDigit(c) || !isDigit(ctx.s.charCodeAt(++ctx.p))) {
|
|
67095
|
+
return parseNumber(ctx, --ctx.p, c, 0, endChr);
|
|
67096
|
+
}
|
|
67097
|
+
if (ctx.s.charCodeAt(ctx.p += 4) === 58)
|
|
67098
|
+
ctx.p += 3;
|
|
67099
|
+
if (ctx.s.charCodeAt(ctx.p) === 46)
|
|
67100
|
+
while (isDigit(ctx.s.charCodeAt(++ctx.p)))
|
|
67101
|
+
;
|
|
67102
|
+
let t = ctx.s.slice(start2, ctx.p);
|
|
67103
|
+
return readDate(ctx, t, 4, false, start2);
|
|
67104
|
+
}
|
|
67105
|
+
function readDate(ctx, str, type, unsafeDelim, errPtr, temporalSuffix) {
|
|
67106
|
+
if (ctx.ld) {
|
|
67107
|
+
let date5 = new TomlDate(str, type, unsafeDelim);
|
|
67108
|
+
if (!date5.isValid())
|
|
67109
|
+
TomlError.x("invalid date", ctx, errPtr);
|
|
67110
|
+
return date5;
|
|
66770
67111
|
}
|
|
66771
|
-
|
|
66772
|
-
|
|
66773
|
-
|
|
66774
|
-
|
|
66775
|
-
|
|
66776
|
-
|
|
66777
|
-
|
|
66778
|
-
|
|
66779
|
-
|
|
66780
|
-
|
|
66781
|
-
|
|
66782
|
-
|
|
66783
|
-
endPtr += +(str[endPtr] === ",");
|
|
67112
|
+
try {
|
|
67113
|
+
if (temporalSuffix)
|
|
67114
|
+
str += temporalSuffix;
|
|
67115
|
+
switch (type) {
|
|
67116
|
+
case 1:
|
|
67117
|
+
return Temporal.ZonedDateTime.from(str);
|
|
67118
|
+
case 2:
|
|
67119
|
+
return Temporal.PlainDateTime.from(str);
|
|
67120
|
+
case 3:
|
|
67121
|
+
return Temporal.PlainDate.from(str);
|
|
67122
|
+
case 4:
|
|
67123
|
+
return Temporal.PlainTime.from(str);
|
|
66784
67124
|
}
|
|
66785
|
-
|
|
67125
|
+
} catch (e) {
|
|
67126
|
+
TomlError.x(e instanceof Error ? e.message : "" + e, ctx, errPtr);
|
|
66786
67127
|
}
|
|
66787
|
-
|
|
66788
|
-
|
|
66789
|
-
|
|
66790
|
-
|
|
66791
|
-
|
|
66792
|
-
|
|
66793
|
-
|
|
67128
|
+
}
|
|
67129
|
+
|
|
67130
|
+
// ../../node_modules/smol-toml/dist/util.js
|
|
67131
|
+
function skipComment(ctx) {
|
|
67132
|
+
for (; ctx.p < ctx.s.length; ctx.p++) {
|
|
67133
|
+
let c = ctx.s.charCodeAt(ctx.p);
|
|
67134
|
+
if (c === 10)
|
|
67135
|
+
break;
|
|
67136
|
+
if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10) {
|
|
67137
|
+
ctx.p++;
|
|
67138
|
+
break;
|
|
67139
|
+
}
|
|
67140
|
+
if (c < 32 && c !== 9 || c === 127) {
|
|
67141
|
+
TomlError.x("control characters are not allowed in comments", ctx);
|
|
67142
|
+
}
|
|
66794
67143
|
}
|
|
66795
|
-
|
|
66796
|
-
|
|
66797
|
-
|
|
67144
|
+
}
|
|
67145
|
+
function skipVoid(ctx, banNewLines, banComments) {
|
|
67146
|
+
let c;
|
|
67147
|
+
while (ctx.p < ctx.s.length) {
|
|
67148
|
+
while (ctx.p < ctx.s.length && ((c = ctx.s.charCodeAt(ctx.p)) === 32 || c === 9 || !banNewLines && (c === 10 || c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)))
|
|
67149
|
+
ctx.p++;
|
|
67150
|
+
if (banComments || c !== 35)
|
|
67151
|
+
break;
|
|
67152
|
+
skipComment(ctx);
|
|
66798
67153
|
}
|
|
66799
|
-
return [
|
|
66800
|
-
parseValue(slice[0], str, ptr, integersAsBigInt),
|
|
66801
|
-
endPtr
|
|
66802
|
-
];
|
|
66803
67154
|
}
|
|
66804
67155
|
|
|
66805
67156
|
// ../../node_modules/smol-toml/dist/struct.js
|
|
66806
|
-
|
|
66807
|
-
|
|
66808
|
-
let
|
|
67157
|
+
function parseKey(ctx, end = 61) {
|
|
67158
|
+
let startPtr;
|
|
67159
|
+
let state = 0;
|
|
66809
67160
|
let parsed = [];
|
|
66810
|
-
let
|
|
66811
|
-
|
|
66812
|
-
throw new TomlError("incomplete key-value: cannot find end of key", {
|
|
66813
|
-
toml: str,
|
|
66814
|
-
ptr
|
|
66815
|
-
});
|
|
66816
|
-
}
|
|
67161
|
+
let sliceStart;
|
|
67162
|
+
let c = ctx.s.charCodeAt(startPtr = ctx.p);
|
|
66817
67163
|
do {
|
|
66818
|
-
|
|
66819
|
-
|
|
66820
|
-
|
|
66821
|
-
|
|
66822
|
-
|
|
66823
|
-
|
|
66824
|
-
|
|
66825
|
-
|
|
66826
|
-
|
|
66827
|
-
|
|
66828
|
-
|
|
66829
|
-
|
|
66830
|
-
|
|
66831
|
-
|
|
66832
|
-
|
|
66833
|
-
|
|
66834
|
-
|
|
66835
|
-
|
|
66836
|
-
|
|
66837
|
-
|
|
66838
|
-
|
|
66839
|
-
|
|
66840
|
-
|
|
66841
|
-
|
|
66842
|
-
|
|
66843
|
-
|
|
66844
|
-
|
|
66845
|
-
|
|
66846
|
-
|
|
66847
|
-
|
|
66848
|
-
|
|
66849
|
-
|
|
66850
|
-
|
|
66851
|
-
|
|
66852
|
-
|
|
66853
|
-
toml: str,
|
|
66854
|
-
ptr
|
|
66855
|
-
});
|
|
66856
|
-
}
|
|
66857
|
-
}
|
|
66858
|
-
parsed.push(parseString(str, ptr, eos));
|
|
66859
|
-
} else {
|
|
66860
|
-
dot = str.indexOf(".", ptr);
|
|
66861
|
-
let part = str.slice(ptr, dot < 0 || dot > endPtr ? endPtr : dot);
|
|
66862
|
-
if (!KEY_PART_RE.test(part)) {
|
|
66863
|
-
throw new TomlError("only letter, numbers, dashes and underscores are allowed in keys", {
|
|
66864
|
-
toml: str,
|
|
66865
|
-
ptr
|
|
66866
|
-
});
|
|
66867
|
-
}
|
|
66868
|
-
parsed.push(part.trimEnd());
|
|
66869
|
-
}
|
|
66870
|
-
}
|
|
66871
|
-
} while (dot + 1 && dot < endPtr);
|
|
66872
|
-
return [parsed, skipVoid(str, endPtr + 1, true, true)];
|
|
66873
|
-
}
|
|
66874
|
-
function parseInlineTable(str, ptr, depth, integersAsBigInt) {
|
|
66875
|
-
let res = {};
|
|
67164
|
+
if (c === end) {
|
|
67165
|
+
if (!state)
|
|
67166
|
+
TomlError.x("unexpected end of key", ctx);
|
|
67167
|
+
if (state === 1)
|
|
67168
|
+
parsed.push(ctx.s.slice(sliceStart, ctx.p));
|
|
67169
|
+
return ctx.p++, parsed;
|
|
67170
|
+
} else if (c === 46) {
|
|
67171
|
+
if (!state)
|
|
67172
|
+
TomlError.x("illegal empty bare key", ctx);
|
|
67173
|
+
if (state === 1)
|
|
67174
|
+
parsed.push(ctx.s.slice(sliceStart, ctx.p));
|
|
67175
|
+
state = 0;
|
|
67176
|
+
} else if (!state && (c === 34 || c === 39)) {
|
|
67177
|
+
if (c === ctx.s.charCodeAt(ctx.p + 1) && c === ctx.s.charCodeAt(ctx.p + 2))
|
|
67178
|
+
TomlError.x("illegal quoted key: multiline strings are not allowed", ctx);
|
|
67179
|
+
parsed.push(parseString(ctx));
|
|
67180
|
+
state = 2;
|
|
67181
|
+
ctx.p--;
|
|
67182
|
+
} else if (c === 32 || c === 9) {
|
|
67183
|
+
if (state === 1) {
|
|
67184
|
+
parsed.push(ctx.s.slice(sliceStart, ctx.p));
|
|
67185
|
+
state = 2;
|
|
67186
|
+
}
|
|
67187
|
+
} else if (state === 2 || c < 48 && c !== 45 || c > 57 && c < 65 || c > 90 && c < 97 && c !== 95 || c > 122) {
|
|
67188
|
+
TomlError.x("illegal character in key", ctx);
|
|
67189
|
+
} else if (!state) {
|
|
67190
|
+
state = 1;
|
|
67191
|
+
sliceStart = ctx.p;
|
|
67192
|
+
}
|
|
67193
|
+
} while (c = ctx.s.charCodeAt(++ctx.p));
|
|
67194
|
+
TomlError.x("incomplete key-value: cannot find end of key", ctx, startPtr);
|
|
67195
|
+
}
|
|
67196
|
+
function parseInlineTable(ctx) {
|
|
67197
|
+
let startPtr = ctx.p++;
|
|
67198
|
+
let res = /* @__PURE__ */ Object.create(null);
|
|
66876
67199
|
let seen = /* @__PURE__ */ new Set();
|
|
66877
67200
|
let c;
|
|
66878
|
-
|
|
66879
|
-
|
|
66880
|
-
if (c ===
|
|
66881
|
-
|
|
66882
|
-
|
|
66883
|
-
|
|
66884
|
-
|
|
66885
|
-
|
|
66886
|
-
|
|
66887
|
-
|
|
66888
|
-
|
|
66889
|
-
|
|
66890
|
-
|
|
66891
|
-
|
|
66892
|
-
|
|
66893
|
-
|
|
66894
|
-
|
|
66895
|
-
|
|
66896
|
-
|
|
66897
|
-
|
|
66898
|
-
|
|
66899
|
-
|
|
66900
|
-
});
|
|
66901
|
-
}
|
|
66902
|
-
if (!hasOwn && k === "__proto__") {
|
|
66903
|
-
Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
|
|
66904
|
-
}
|
|
67201
|
+
while (ctx.p < ctx.s.length) {
|
|
67202
|
+
skipVoid(ctx);
|
|
67203
|
+
if ((c = ctx.s.charCodeAt(ctx.p)) === 125) {
|
|
67204
|
+
ctx.p++;
|
|
67205
|
+
return res;
|
|
67206
|
+
}
|
|
67207
|
+
let k;
|
|
67208
|
+
let t = res;
|
|
67209
|
+
let hasOwn = false;
|
|
67210
|
+
let errPtr = ctx.p;
|
|
67211
|
+
let key = parseKey(ctx);
|
|
67212
|
+
for (let i = 0; i < key.length; i++) {
|
|
67213
|
+
if (i)
|
|
67214
|
+
t = hasOwn ? t[k] : t[k] = /* @__PURE__ */ Object.create(null);
|
|
67215
|
+
k = key[i];
|
|
67216
|
+
if ((hasOwn = Object.hasOwn(t, k)) && (typeof t[k] !== "object" || seen.has(t[k]))) {
|
|
67217
|
+
TomlError.x("trying to redefine an already defined value", ctx, errPtr);
|
|
67218
|
+
}
|
|
67219
|
+
let unsafe = k === "__proto__";
|
|
67220
|
+
if (ctx.uk && (unsafe || k === "constructor")) {
|
|
67221
|
+
t = ctx.uk !== 1 && TomlError.x("document contains an unsafe property", ctx, errPtr);
|
|
67222
|
+
break;
|
|
66905
67223
|
}
|
|
66906
|
-
if (hasOwn) {
|
|
66907
|
-
|
|
66908
|
-
toml: str,
|
|
66909
|
-
ptr
|
|
66910
|
-
});
|
|
67224
|
+
if (!hasOwn && unsafe) {
|
|
67225
|
+
Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
|
|
66911
67226
|
}
|
|
66912
|
-
|
|
67227
|
+
}
|
|
67228
|
+
if (hasOwn) {
|
|
67229
|
+
TomlError.x("trying to redefine an already defined value", ctx, errPtr);
|
|
67230
|
+
}
|
|
67231
|
+
skipVoid(ctx, true, true);
|
|
67232
|
+
let value2 = extractValue(
|
|
67233
|
+
ctx,
|
|
67234
|
+
125
|
|
67235
|
+
/* } */
|
|
67236
|
+
);
|
|
67237
|
+
if (t && typeof (t[k] = value2) === "object")
|
|
66913
67238
|
seen.add(value2);
|
|
66914
|
-
|
|
66915
|
-
|
|
67239
|
+
skipVoid(ctx);
|
|
67240
|
+
if ((c = ctx.s.charCodeAt(ctx.p++)) === 125) {
|
|
67241
|
+
return res;
|
|
66916
67242
|
}
|
|
67243
|
+
if (c !== 44)
|
|
67244
|
+
TomlError.x("expected comma or end of structure", ctx, ctx.p - 1);
|
|
66917
67245
|
}
|
|
66918
|
-
|
|
66919
|
-
throw new TomlError("unfinished table encountered", {
|
|
66920
|
-
toml: str,
|
|
66921
|
-
ptr
|
|
66922
|
-
});
|
|
66923
|
-
}
|
|
66924
|
-
return [res, ptr];
|
|
67246
|
+
TomlError.x("unfinished table", ctx, startPtr);
|
|
66925
67247
|
}
|
|
66926
|
-
function parseArray(
|
|
67248
|
+
function parseArray(ctx) {
|
|
67249
|
+
let startPtr = ctx.p++;
|
|
66927
67250
|
let res = [];
|
|
66928
67251
|
let c;
|
|
66929
|
-
|
|
66930
|
-
|
|
66931
|
-
if (c ===
|
|
66932
|
-
|
|
66933
|
-
|
|
66934
|
-
|
|
66935
|
-
|
|
66936
|
-
|
|
66937
|
-
|
|
66938
|
-
|
|
66939
|
-
|
|
66940
|
-
|
|
66941
|
-
|
|
66942
|
-
|
|
66943
|
-
|
|
66944
|
-
|
|
66945
|
-
|
|
66946
|
-
toml: str,
|
|
66947
|
-
ptr
|
|
66948
|
-
});
|
|
67252
|
+
while (ctx.p < ctx.s.length) {
|
|
67253
|
+
skipVoid(ctx);
|
|
67254
|
+
if ((c = ctx.s.charCodeAt(ctx.p)) === 93) {
|
|
67255
|
+
ctx.p++;
|
|
67256
|
+
return res;
|
|
67257
|
+
}
|
|
67258
|
+
res.push(extractValue(
|
|
67259
|
+
ctx,
|
|
67260
|
+
93
|
|
67261
|
+
/* ] */
|
|
67262
|
+
));
|
|
67263
|
+
skipVoid(ctx);
|
|
67264
|
+
if ((c = ctx.s.charCodeAt(ctx.p++)) === 93) {
|
|
67265
|
+
return res;
|
|
67266
|
+
}
|
|
67267
|
+
if (c !== 44)
|
|
67268
|
+
TomlError.x("expected comma or end of structure", ctx, ctx.p - 1);
|
|
66949
67269
|
}
|
|
66950
|
-
|
|
67270
|
+
TomlError.x("unfinished array", ctx, startPtr);
|
|
66951
67271
|
}
|
|
66952
67272
|
|
|
66953
67273
|
// ../../node_modules/smol-toml/dist/parse.js
|
|
66954
|
-
function peekTable(key, table, meta3, type) {
|
|
67274
|
+
function peekTable(ctx, key, table, meta3, type) {
|
|
66955
67275
|
let t = table;
|
|
66956
67276
|
let m = meta3;
|
|
66957
67277
|
let k;
|
|
@@ -66959,7 +67279,7 @@ function peekTable(key, table, meta3, type) {
|
|
|
66959
67279
|
let state;
|
|
66960
67280
|
for (let i = 0; i < key.length; i++) {
|
|
66961
67281
|
if (i) {
|
|
66962
|
-
t = hasOwn ? t[k] : t[k] =
|
|
67282
|
+
t = hasOwn ? t[k] : t[k] = /* @__PURE__ */ Object.create(null);
|
|
66963
67283
|
m = (state = m[k]).c;
|
|
66964
67284
|
if (type === 0 && (state.t === 1 || state.t === 2)) {
|
|
66965
67285
|
return null;
|
|
@@ -66975,7 +67295,10 @@ function peekTable(key, table, meta3, type) {
|
|
|
66975
67295
|
return null;
|
|
66976
67296
|
}
|
|
66977
67297
|
if (!hasOwn) {
|
|
66978
|
-
|
|
67298
|
+
let unsafe = k === "__proto__";
|
|
67299
|
+
if (ctx.uk && (unsafe || k === "constructor"))
|
|
67300
|
+
return false;
|
|
67301
|
+
if (unsafe) {
|
|
66979
67302
|
Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
|
|
66980
67303
|
Object.defineProperty(m, k, { enumerable: true, configurable: true, writable: true });
|
|
66981
67304
|
}
|
|
@@ -66983,7 +67306,7 @@ function peekTable(key, table, meta3, type) {
|
|
|
66983
67306
|
t: i < key.length - 1 && type === 2 ? 3 : type,
|
|
66984
67307
|
d: false,
|
|
66985
67308
|
i: 0,
|
|
66986
|
-
c:
|
|
67309
|
+
c: /* @__PURE__ */ Object.create(null)
|
|
66987
67310
|
};
|
|
66988
67311
|
}
|
|
66989
67312
|
}
|
|
@@ -66996,94 +67319,124 @@ function peekTable(key, table, meta3, type) {
|
|
|
66996
67319
|
state.d = true;
|
|
66997
67320
|
t[k] = [];
|
|
66998
67321
|
}
|
|
66999
|
-
t[k].push(t =
|
|
67000
|
-
state.c[state.i++] = state = { t: 1, d: false, i: 0, c:
|
|
67322
|
+
t[k].push(t = /* @__PURE__ */ Object.create(null));
|
|
67323
|
+
state.c[state.i++] = state = { t: 1, d: false, i: 0, c: /* @__PURE__ */ Object.create(null) };
|
|
67001
67324
|
}
|
|
67002
67325
|
if (state.d) {
|
|
67003
67326
|
return null;
|
|
67004
67327
|
}
|
|
67005
67328
|
state.d = true;
|
|
67006
67329
|
if (type === 1) {
|
|
67007
|
-
t = hasOwn ? t[k] : t[k] =
|
|
67330
|
+
t = hasOwn ? t[k] : t[k] = /* @__PURE__ */ Object.create(null);
|
|
67008
67331
|
} else if (type === 0 && hasOwn) {
|
|
67009
67332
|
return null;
|
|
67010
67333
|
}
|
|
67011
67334
|
return [k, t, state.c];
|
|
67012
67335
|
}
|
|
67013
|
-
function
|
|
67014
|
-
|
|
67015
|
-
|
|
67336
|
+
function validateTablePeek(ctx, peek, ptr) {
|
|
67337
|
+
if (peek === null || ctx.uk === 2)
|
|
67338
|
+
TomlError.x(peek === null ? "trying to redefine an already defined table or value" : "document contains an unsafe property", ctx, ptr);
|
|
67339
|
+
}
|
|
67340
|
+
function parse3(toml, options = {}) {
|
|
67341
|
+
let ctx = {
|
|
67342
|
+
s: toml,
|
|
67343
|
+
p: 0,
|
|
67344
|
+
d: options.maxDepth ?? 1e3,
|
|
67345
|
+
bi: options.integersAsBigInt ?? false,
|
|
67346
|
+
ld: options.useLegacyDate ?? true,
|
|
67347
|
+
uk: options.unsafeKeyBehaviour === "throw" ? 2 : options.unsafeKeyBehaviour === "drop" ? 1 : 0
|
|
67348
|
+
};
|
|
67349
|
+
let res = /* @__PURE__ */ Object.create(null);
|
|
67350
|
+
let meta3 = /* @__PURE__ */ Object.create(null);
|
|
67351
|
+
let tmp;
|
|
67352
|
+
let skipping = false;
|
|
67016
67353
|
let tbl = res;
|
|
67017
67354
|
let m = meta3;
|
|
67018
|
-
|
|
67019
|
-
|
|
67020
|
-
|
|
67021
|
-
|
|
67355
|
+
if (toml.charCodeAt(0) === 65279)
|
|
67356
|
+
ctx.p++;
|
|
67357
|
+
skipVoid(ctx);
|
|
67358
|
+
while (ctx.p < toml.length) {
|
|
67359
|
+
if (toml.charCodeAt(ctx.p) === 91) {
|
|
67360
|
+
let isTableArray = toml.charCodeAt(++ctx.p) === 91;
|
|
67361
|
+
tmp = ctx.p += +isTableArray;
|
|
67362
|
+
skipping = false;
|
|
67363
|
+
let k = parseKey(
|
|
67364
|
+
ctx,
|
|
67365
|
+
93
|
|
67366
|
+
/* ] */
|
|
67367
|
+
);
|
|
67022
67368
|
if (isTableArray) {
|
|
67023
|
-
if (toml
|
|
67024
|
-
|
|
67025
|
-
toml,
|
|
67026
|
-
ptr: k[1] - 1
|
|
67027
|
-
});
|
|
67369
|
+
if (toml.charCodeAt(ctx.p) !== 93) {
|
|
67370
|
+
TomlError.x("expected end of table array declaration", ctx);
|
|
67028
67371
|
}
|
|
67029
|
-
|
|
67372
|
+
ctx.p++;
|
|
67030
67373
|
}
|
|
67031
67374
|
let p = peekTable(
|
|
67032
|
-
|
|
67375
|
+
ctx,
|
|
67376
|
+
k,
|
|
67033
67377
|
res,
|
|
67034
67378
|
meta3,
|
|
67035
67379
|
isTableArray ? 2 : 1
|
|
67036
67380
|
/* Type.EXPLICIT */
|
|
67037
67381
|
);
|
|
67038
67382
|
if (!p) {
|
|
67039
|
-
|
|
67040
|
-
|
|
67041
|
-
|
|
67042
|
-
|
|
67383
|
+
validateTablePeek(ctx, p, tmp);
|
|
67384
|
+
skipping = true;
|
|
67385
|
+
} else {
|
|
67386
|
+
m = p[2];
|
|
67387
|
+
tbl = p[1];
|
|
67043
67388
|
}
|
|
67044
|
-
m = p[2];
|
|
67045
|
-
tbl = p[1];
|
|
67046
|
-
ptr = k[1];
|
|
67047
67389
|
} else {
|
|
67048
|
-
|
|
67390
|
+
tmp = ctx.p;
|
|
67391
|
+
let k = parseKey(ctx);
|
|
67049
67392
|
let p = peekTable(
|
|
67050
|
-
|
|
67393
|
+
ctx,
|
|
67394
|
+
k,
|
|
67051
67395
|
tbl,
|
|
67052
67396
|
m,
|
|
67053
67397
|
0
|
|
67054
67398
|
/* Type.DOTTED */
|
|
67055
67399
|
);
|
|
67056
|
-
if (!p)
|
|
67057
|
-
|
|
67058
|
-
|
|
67059
|
-
|
|
67060
|
-
|
|
67061
|
-
|
|
67062
|
-
let v = extractValue(toml, k[1], void 0, maxDepth, integersAsBigInt);
|
|
67063
|
-
p[1][p[0]] = v[0];
|
|
67064
|
-
ptr = v[1];
|
|
67400
|
+
if (!p && !skipping)
|
|
67401
|
+
validateTablePeek(ctx, p, tmp);
|
|
67402
|
+
skipVoid(ctx, true, true);
|
|
67403
|
+
let v = extractValue(ctx, void 0);
|
|
67404
|
+
if (p && !skipping)
|
|
67405
|
+
p[1][p[0]] = v;
|
|
67065
67406
|
}
|
|
67066
|
-
|
|
67067
|
-
if (toml
|
|
67068
|
-
|
|
67069
|
-
toml,
|
|
67070
|
-
ptr
|
|
67071
|
-
});
|
|
67407
|
+
skipVoid(ctx, true);
|
|
67408
|
+
if (ctx.p < toml.length && (tmp = toml.charCodeAt(ctx.p)) !== 10 && (tmp !== 13 || toml.charCodeAt(ctx.p + 1) !== 10)) {
|
|
67409
|
+
TomlError.x("each key-value declaration must be followed by an end-of-line", ctx);
|
|
67072
67410
|
}
|
|
67073
|
-
|
|
67411
|
+
skipVoid(ctx);
|
|
67074
67412
|
}
|
|
67075
67413
|
return res;
|
|
67076
67414
|
}
|
|
67077
67415
|
|
|
67078
67416
|
// ../../node_modules/smol-toml/dist/stringify.js
|
|
67079
67417
|
var BARE_KEY = /^[a-z0-9-_]+$/i;
|
|
67418
|
+
var HAS_WELLFORMED = !!"".isWellFormed;
|
|
67080
67419
|
function extendedTypeOf(obj) {
|
|
67081
67420
|
let type = typeof obj;
|
|
67082
67421
|
if (type === "object") {
|
|
67083
67422
|
if (Array.isArray(obj))
|
|
67084
67423
|
return "array";
|
|
67085
|
-
if (obj instanceof Date)
|
|
67424
|
+
if (typeof obj.getUTCDate === "function" && obj instanceof Date)
|
|
67086
67425
|
return "date";
|
|
67426
|
+
if (globalThis.Temporal) {
|
|
67427
|
+
if (obj.until) {
|
|
67428
|
+
if (obj instanceof Temporal.ZonedDateTime)
|
|
67429
|
+
return "temporal/tz+uc";
|
|
67430
|
+
if (obj instanceof Temporal.PlainDateTime || obj instanceof Temporal.PlainDate)
|
|
67431
|
+
return "temporal/uc";
|
|
67432
|
+
if (obj instanceof Temporal.PlainTime || obj instanceof Temporal.Instant)
|
|
67433
|
+
return "temporal";
|
|
67434
|
+
if (obj instanceof Temporal.PlainYearMonth)
|
|
67435
|
+
return "temporal/x";
|
|
67436
|
+
} else if (obj.toPlainDate && obj instanceof Temporal.PlainMonthDay || obj.negated && obj instanceof Temporal.Duration) {
|
|
67437
|
+
return "temporal/x";
|
|
67438
|
+
}
|
|
67439
|
+
}
|
|
67087
67440
|
}
|
|
67088
67441
|
return type;
|
|
67089
67442
|
}
|
|
@@ -67094,44 +67447,76 @@ function isArrayOfTables(obj) {
|
|
|
67094
67447
|
}
|
|
67095
67448
|
return obj.length != 0;
|
|
67096
67449
|
}
|
|
67450
|
+
function formatWellFormedStringUnchecked(s) {
|
|
67451
|
+
return JSON.stringify(s).replaceAll("\x7F", "\\u007f");
|
|
67452
|
+
}
|
|
67097
67453
|
function formatString(s) {
|
|
67098
|
-
return
|
|
67454
|
+
return formatWellFormedStringUnchecked(HAS_WELLFORMED ? s.toWellFormed() : s);
|
|
67099
67455
|
}
|
|
67100
|
-
function
|
|
67456
|
+
function formatKey(s) {
|
|
67457
|
+
if (BARE_KEY.test(s))
|
|
67458
|
+
return s;
|
|
67459
|
+
if (HAS_WELLFORMED && !s.isWellFormed())
|
|
67460
|
+
throw new RangeError("key contains illegal lone surrogates");
|
|
67461
|
+
return formatWellFormedStringUnchecked(s);
|
|
67462
|
+
}
|
|
67463
|
+
function stringifyValue(val, type, depth, numberAsFloat, strictTemporal) {
|
|
67101
67464
|
if (depth === 0) {
|
|
67102
67465
|
throw new Error("Could not stringify the object: maximum object depth exceeded");
|
|
67103
67466
|
}
|
|
67104
|
-
|
|
67105
|
-
|
|
67106
|
-
|
|
67107
|
-
|
|
67108
|
-
|
|
67109
|
-
|
|
67110
|
-
|
|
67111
|
-
|
|
67112
|
-
|
|
67113
|
-
|
|
67114
|
-
|
|
67115
|
-
|
|
67116
|
-
|
|
67117
|
-
|
|
67118
|
-
|
|
67119
|
-
|
|
67120
|
-
|
|
67121
|
-
|
|
67122
|
-
|
|
67123
|
-
|
|
67124
|
-
|
|
67125
|
-
|
|
67126
|
-
|
|
67127
|
-
|
|
67128
|
-
|
|
67129
|
-
|
|
67130
|
-
|
|
67131
|
-
|
|
67467
|
+
switch (type) {
|
|
67468
|
+
// @ts-expect-error -- intentional fallthrough case
|
|
67469
|
+
case "number":
|
|
67470
|
+
if (isNaN(val))
|
|
67471
|
+
return "nan";
|
|
67472
|
+
if (val === Infinity)
|
|
67473
|
+
return "inf";
|
|
67474
|
+
if (val === -Infinity)
|
|
67475
|
+
return "-inf";
|
|
67476
|
+
if (Number.isInteger(val) && (numberAsFloat || !Number.isSafeInteger(val)))
|
|
67477
|
+
return val.toFixed(1);
|
|
67478
|
+
case "bigint":
|
|
67479
|
+
case "boolean":
|
|
67480
|
+
case "temporal":
|
|
67481
|
+
return val.toString();
|
|
67482
|
+
case "string":
|
|
67483
|
+
return formatString(val);
|
|
67484
|
+
case "date":
|
|
67485
|
+
if (isNaN(val.getTime()))
|
|
67486
|
+
throw new TypeError("cannot serialize invalid date");
|
|
67487
|
+
return val.toISOString();
|
|
67488
|
+
case "object":
|
|
67489
|
+
return stringifyInlineTable(val, depth, numberAsFloat, strictTemporal);
|
|
67490
|
+
case "array":
|
|
67491
|
+
return stringifyArray(val, depth, numberAsFloat, strictTemporal);
|
|
67492
|
+
// @ts-expect-error -- intentional fallthrough case
|
|
67493
|
+
case "temporal/tz+uc":
|
|
67494
|
+
if (strictTemporal) {
|
|
67495
|
+
let tz = val.timeZoneId;
|
|
67496
|
+
let tzc = tz.charCodeAt(0);
|
|
67497
|
+
if (
|
|
67498
|
+
// Classic offset
|
|
67499
|
+
tzc !== 43 && tzc !== 45 && // Fast pre-check pass; see below for the actually accepted values
|
|
67500
|
+
(tzc !== 85 && tzc !== 71 && tzc !== 90 && tzc !== 69 || // UTC and its aliases; Temporal implementations don't all canonicalise unfortunately
|
|
67501
|
+
tz !== "UTC" && tz !== "UCT" && tz !== "Universal" && tz !== "Zulu" && // GMT is a TZ but it's for all intents and purposes equivalent to UTC. Safe to downgrade.
|
|
67502
|
+
!tz.startsWith("GMT") && tz !== "Greenwich" && // Etc/* are all safe to downgrade to offset (either UTC, GMT, or offset)
|
|
67503
|
+
!tz.startsWith("Etc/"))
|
|
67504
|
+
) {
|
|
67505
|
+
throw new TypeError("Temporal objects with an IANA timezone are not allowed in Temporal strict mode");
|
|
67506
|
+
}
|
|
67507
|
+
}
|
|
67508
|
+
case "temporal/uc":
|
|
67509
|
+
if (strictTemporal && val.calendarId !== "iso8601")
|
|
67510
|
+
throw new TypeError("Temporal objects with a non-default calendar are not allowed in Temporal strict mode");
|
|
67511
|
+
return val.toString({
|
|
67512
|
+
calendarName: "never",
|
|
67513
|
+
timeZoneName: "never"
|
|
67514
|
+
});
|
|
67515
|
+
case "temporal/x":
|
|
67516
|
+
throw new TypeError("Unsupported " + val[Symbol.toStringTag]);
|
|
67132
67517
|
}
|
|
67133
67518
|
}
|
|
67134
|
-
function stringifyInlineTable(obj, depth, numberAsFloat) {
|
|
67519
|
+
function stringifyInlineTable(obj, depth, numberAsFloat, strictTemporal) {
|
|
67135
67520
|
let keys = Object.keys(obj);
|
|
67136
67521
|
if (keys.length === 0)
|
|
67137
67522
|
return "{}";
|
|
@@ -67140,13 +67525,11 @@ function stringifyInlineTable(obj, depth, numberAsFloat) {
|
|
|
67140
67525
|
let k = keys[i];
|
|
67141
67526
|
if (i)
|
|
67142
67527
|
res += ", ";
|
|
67143
|
-
res +=
|
|
67144
|
-
res += " = ";
|
|
67145
|
-
res += stringifyValue(obj[k], extendedTypeOf(obj[k]), depth - 1, numberAsFloat);
|
|
67528
|
+
res += formatKey(k) + " = " + stringifyValue(obj[k], extendedTypeOf(obj[k]), depth - 1, numberAsFloat, strictTemporal);
|
|
67146
67529
|
}
|
|
67147
67530
|
return res + " }";
|
|
67148
67531
|
}
|
|
67149
|
-
function stringifyArray(array2, depth, numberAsFloat) {
|
|
67532
|
+
function stringifyArray(array2, depth, numberAsFloat, strictTemporal) {
|
|
67150
67533
|
if (array2.length === 0)
|
|
67151
67534
|
return "[]";
|
|
67152
67535
|
let res = "[ ";
|
|
@@ -67156,11 +67539,11 @@ function stringifyArray(array2, depth, numberAsFloat) {
|
|
|
67156
67539
|
if (array2[i] === null || array2[i] === void 0) {
|
|
67157
67540
|
throw new TypeError("arrays cannot contain null or undefined values");
|
|
67158
67541
|
}
|
|
67159
|
-
res += stringifyValue(array2[i], extendedTypeOf(array2[i]), depth - 1, numberAsFloat);
|
|
67542
|
+
res += stringifyValue(array2[i], extendedTypeOf(array2[i]), depth - 1, numberAsFloat, strictTemporal);
|
|
67160
67543
|
}
|
|
67161
67544
|
return res + " ]";
|
|
67162
67545
|
}
|
|
67163
|
-
function stringifyArrayTable(array2, key, depth, numberAsFloat) {
|
|
67546
|
+
function stringifyArrayTable(array2, key, depth, numberAsFloat, strictTemporal) {
|
|
67164
67547
|
if (depth === 0) {
|
|
67165
67548
|
throw new Error("Could not stringify the object: maximum object depth exceeded");
|
|
67166
67549
|
}
|
|
@@ -67168,11 +67551,11 @@ function stringifyArrayTable(array2, key, depth, numberAsFloat) {
|
|
|
67168
67551
|
for (let i = 0; i < array2.length; i++) {
|
|
67169
67552
|
res += `${res && "\n"}[[${key}]]
|
|
67170
67553
|
`;
|
|
67171
|
-
res += stringifyTable(0, array2[i], key, depth, numberAsFloat);
|
|
67554
|
+
res += stringifyTable(0, array2[i], key, depth, numberAsFloat, strictTemporal);
|
|
67172
67555
|
}
|
|
67173
67556
|
return res;
|
|
67174
67557
|
}
|
|
67175
|
-
function stringifyTable(tableKey, obj, prefix, depth, numberAsFloat) {
|
|
67558
|
+
function stringifyTable(tableKey, obj, prefix, depth, numberAsFloat, strictTemporal) {
|
|
67176
67559
|
if (depth === 0) {
|
|
67177
67560
|
throw new Error("Could not stringify the object: maximum object depth exceeded");
|
|
67178
67561
|
}
|
|
@@ -67186,16 +67569,16 @@ function stringifyTable(tableKey, obj, prefix, depth, numberAsFloat) {
|
|
|
67186
67569
|
if (type === "symbol" || type === "function") {
|
|
67187
67570
|
throw new TypeError(`cannot serialize values of type '${type}'`);
|
|
67188
67571
|
}
|
|
67189
|
-
let key =
|
|
67572
|
+
let key = formatKey(k);
|
|
67190
67573
|
if (type === "array" && isArrayOfTables(obj[k])) {
|
|
67191
|
-
tables += (tables && "\n") + stringifyArrayTable(obj[k], prefix ? `${prefix}.${key}` : key, depth - 1, numberAsFloat);
|
|
67574
|
+
tables += (tables && "\n") + stringifyArrayTable(obj[k], prefix ? `${prefix}.${key}` : key, depth - 1, numberAsFloat, strictTemporal);
|
|
67192
67575
|
} else if (type === "object") {
|
|
67193
67576
|
let tblKey = prefix ? `${prefix}.${key}` : key;
|
|
67194
|
-
tables += (tables && "\n") + stringifyTable(tblKey, obj[k], tblKey, depth - 1, numberAsFloat);
|
|
67577
|
+
tables += (tables && "\n") + stringifyTable(tblKey, obj[k], tblKey, depth - 1, numberAsFloat, strictTemporal);
|
|
67195
67578
|
} else {
|
|
67196
67579
|
preamble += key;
|
|
67197
67580
|
preamble += " = ";
|
|
67198
|
-
preamble += stringifyValue(obj[k], type, depth, numberAsFloat);
|
|
67581
|
+
preamble += stringifyValue(obj[k], type, depth, numberAsFloat, strictTemporal);
|
|
67199
67582
|
preamble += "\n";
|
|
67200
67583
|
}
|
|
67201
67584
|
}
|
|
@@ -67206,11 +67589,11 @@ ${preamble}` : `[${tableKey}]`;
|
|
|
67206
67589
|
return preamble && tables ? `${preamble}
|
|
67207
67590
|
${tables}` : preamble || tables;
|
|
67208
67591
|
}
|
|
67209
|
-
function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false } = {}) {
|
|
67592
|
+
function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false, strictTemporal = false } = {}) {
|
|
67210
67593
|
if (extendedTypeOf(obj) !== "object") {
|
|
67211
67594
|
throw new TypeError("stringify can only be called with an object");
|
|
67212
67595
|
}
|
|
67213
|
-
let str = stringifyTable(0, obj, "", maxDepth, numbersAsFloat);
|
|
67596
|
+
let str = stringifyTable(0, obj, "", maxDepth, numbersAsFloat, strictTemporal);
|
|
67214
67597
|
if (str[str.length - 1] !== "\n")
|
|
67215
67598
|
return str + "\n";
|
|
67216
67599
|
return str;
|
|
@@ -71067,12 +71450,12 @@ function classifyFileKind(path4) {
|
|
|
71067
71450
|
return "other";
|
|
71068
71451
|
}
|
|
71069
71452
|
function classifyPreview(path4, bytes) {
|
|
71070
|
-
const
|
|
71071
|
-
if (IMAGE_EXTENSIONS2.has(
|
|
71453
|
+
const extension2 = import_node_path62.posix.extname(path4).toLowerCase();
|
|
71454
|
+
if (IMAGE_EXTENSIONS2.has(extension2)) return "image";
|
|
71072
71455
|
if (bytes.includes(0)) return "binary";
|
|
71073
|
-
if (MARKDOWN_EXTENSIONS.has(
|
|
71074
|
-
if (CODE_EXTENSIONS.has(
|
|
71075
|
-
if (TEXT_EXTENSIONS.has(
|
|
71456
|
+
if (MARKDOWN_EXTENSIONS.has(extension2)) return "markdown";
|
|
71457
|
+
if (CODE_EXTENSIONS.has(extension2) || path4.startsWith("scripts/")) return "code";
|
|
71458
|
+
if (TEXT_EXTENSIONS.has(extension2) || looksLikeUtf8Text(bytes)) return "text";
|
|
71076
71459
|
return "binary";
|
|
71077
71460
|
}
|
|
71078
71461
|
function looksLikeUtf8Text(bytes) {
|
|
@@ -75314,6 +75697,7 @@ function openRunLog(path4, clock) {
|
|
|
75314
75697
|
(0, import_node_fs34.ftruncateSync)(fd, size);
|
|
75315
75698
|
(0, import_node_fs34.fsyncSync)(fd);
|
|
75316
75699
|
}
|
|
75700
|
+
const droppedTailBytes = fileSize - size;
|
|
75317
75701
|
let dirty = false;
|
|
75318
75702
|
const sync = () => {
|
|
75319
75703
|
(0, import_node_fs34.fsyncSync)(fd);
|
|
@@ -75342,6 +75726,7 @@ function openRunLog(path4, clock) {
|
|
|
75342
75726
|
return toByteOffset(size);
|
|
75343
75727
|
},
|
|
75344
75728
|
size: () => toByteOffset(size),
|
|
75729
|
+
droppedTailBytes,
|
|
75345
75730
|
syncIfDirty: () => {
|
|
75346
75731
|
if (dirty) sync();
|
|
75347
75732
|
},
|
|
@@ -77017,7 +77402,7 @@ async function openSessions(deps) {
|
|
|
77017
77402
|
if (last === null || last.update.sessionUpdate === "_alan/run.ended") return;
|
|
77018
77403
|
const writer = __using(_stack, openRunLog(runDirectory(paths.runs, runId).log, clock));
|
|
77019
77404
|
writer.append(runEnded({ outcome: "interrupted", message: "The computer stopped mid-turn" }));
|
|
77020
|
-
log.warn("sessions.run_interrupted", { runId });
|
|
77405
|
+
log.warn("sessions.run_interrupted", { runId, droppedTailBytes: writer.droppedTailBytes });
|
|
77021
77406
|
deps.onAppended(runId);
|
|
77022
77407
|
} catch (_) {
|
|
77023
77408
|
var _error = _, _hasError = true;
|
|
@@ -77149,7 +77534,10 @@ async function openSessions(deps) {
|
|
|
77149
77534
|
for (const runId of await unendedRunsOf(conversationId)) busy.add(runId);
|
|
77150
77535
|
}
|
|
77151
77536
|
for (const runId of await recentRunIds()) {
|
|
77152
|
-
if (
|
|
77537
|
+
if (busy.has(runId)) continue;
|
|
77538
|
+
await markInterrupted(runId).catch(
|
|
77539
|
+
(error62) => log.warn("sessions.interrupt_failed", { runId, error: error62 })
|
|
77540
|
+
);
|
|
77153
77541
|
}
|
|
77154
77542
|
};
|
|
77155
77543
|
const spawn11 = async (conversationId) => {
|
|
@@ -81969,10 +82357,13 @@ var XHR = class extends BaseXHR {
|
|
|
81969
82357
|
}
|
|
81970
82358
|
};
|
|
81971
82359
|
|
|
81972
|
-
// ../../node_modules/
|
|
82360
|
+
// ../../node_modules/ws/wrapper.mjs
|
|
81973
82361
|
var import_stream = __toESM(require_stream(), 1);
|
|
82362
|
+
var import_extension = __toESM(require_extension(), 1);
|
|
82363
|
+
var import_permessage_deflate = __toESM(require_permessage_deflate(), 1);
|
|
81974
82364
|
var import_receiver = __toESM(require_receiver(), 1);
|
|
81975
82365
|
var import_sender = __toESM(require_sender(), 1);
|
|
82366
|
+
var import_subprotocol = __toESM(require_subprotocol(), 1);
|
|
81976
82367
|
var import_websocket = __toESM(require_websocket(), 1);
|
|
81977
82368
|
var import_websocket_server = __toESM(require_websocket_server(), 1);
|
|
81978
82369
|
|
|
@@ -87751,10 +88142,10 @@ xmlhttprequest-ssl/lib/XMLHttpRequest.js:
|
|
|
87751
88142
|
*)
|
|
87752
88143
|
|
|
87753
88144
|
smol-toml/dist/error.js:
|
|
87754
|
-
smol-toml/dist/util.js:
|
|
87755
|
-
smol-toml/dist/date.js:
|
|
87756
88145
|
smol-toml/dist/primitive.js:
|
|
88146
|
+
smol-toml/dist/date.js:
|
|
87757
88147
|
smol-toml/dist/extract.js:
|
|
88148
|
+
smol-toml/dist/util.js:
|
|
87758
88149
|
smol-toml/dist/struct.js:
|
|
87759
88150
|
smol-toml/dist/parse.js:
|
|
87760
88151
|
smol-toml/dist/stringify.js:
|