@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.
Files changed (3) hide show
  1. package/alan-agent.cjs +1067 -676
  2. package/alan-holder.cjs +274 -62
  3. 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 extension = import_node_path18.win32.extname(base).toLowerCase();
24765
- return extension === ".exe" || extension === ".com" || hasExtension(base, extensions) ? [base] : extensions.map((ext) => `${base}${ext}`);
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: 50,
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: 60,
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: 70,
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: 80,
28057
+ sortOrder: 160,
27913
28058
  upstreamModelId: "nvidia/nemotron-3-super-120b-a12b",
27914
- contextWindow: 262144,
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: 90,
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
- id: "nvidia/nemotron-3.5-lightning",
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: 110,
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: 120,
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: 130,
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: "minimax/minimax-m3.1-flash",
27974
- name: "MiniMax M3.1 Flash",
27975
- description: "Fast multimodal MiniMax for high-volume work",
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: 140,
27979
- upstreamModelId: "minimax/minimax-m3.1-flash",
27980
- contextWindow: 1048576,
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: "minimax/minimax-m3",
27985
- name: "MiniMax M3",
27986
- description: "MiniMax's full-size multimodal agentic model",
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: 150,
27990
- upstreamModelId: "minimax/minimax-m3",
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(new Error("OpenCode request timed out")));
33841
- outgoing.on("error", reject);
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 createOpenCodeDriver(options = {}) {
35811
- const resolved = {
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 extension = item?.type === "Extension" ? `/${asString(item.kind)}` : "";
42083
- return [unhandledUpdate(`rollout.item.${asString(item?.type)}${extension}`, payload)];
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/engine.io-client/node_modules/ws/lib/constants.js
56832
+ // ../../node_modules/ws/lib/constants.js
56623
56833
  var require_constants2 = __commonJS({
56624
- "../../node_modules/engine.io-client/node_modules/ws/lib/constants.js"(exports2, module2) {
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/engine.io-client/node_modules/ws/lib/buffer-util.js
56855
+ // ../../node_modules/ws/lib/buffer-util.js
56645
56856
  var require_buffer_util = __commonJS({
56646
- "../../node_modules/engine.io-client/node_modules/ws/lib/buffer-util.js"(exports2, module2) {
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/engine.io-client/node_modules/ws/lib/limiter.js
56930
+ // ../../node_modules/ws/lib/limiter.js
56720
56931
  var require_limiter = __commonJS({
56721
- "../../node_modules/engine.io-client/node_modules/ws/lib/limiter.js"(exports2, module2) {
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/engine.io-client/node_modules/ws/lib/permessage-deflate.js
56980
+ // ../../node_modules/ws/lib/permessage-deflate.js
56770
56981
  var require_permessage_deflate = __commonJS({
56771
- "../../node_modules/engine.io-client/node_modules/ws/lib/permessage-deflate.js"(exports2, module2) {
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 PerMessageDeflate = class {
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, isServer, maxPayload) {
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._isServer = !!isServer;
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 = PerMessageDeflate;
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/engine.io-client/node_modules/ws/lib/validation.js
57363
+ // ../../node_modules/ws/lib/validation.js
57153
57364
  var require_validation = __commonJS({
57154
- "../../node_modules/engine.io-client/node_modules/ws/lib/validation.js"(exports2, module2) {
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/engine.io-client/node_modules/ws/lib/receiver.js
57564
+ // ../../node_modules/ws/lib/receiver.js
57354
57565
  var require_receiver = __commonJS({
57355
- "../../node_modules/engine.io-client/node_modules/ws/lib/receiver.js"(exports2, module2) {
57566
+ "../../node_modules/ws/lib/receiver.js"(exports2, module2) {
57356
57567
  "use strict";
57357
57568
  var { Writable } = require("stream");
57358
- var PerMessageDeflate = require_permessage_deflate();
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[PerMessageDeflate.extensionName]) {
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[PerMessageDeflate.extensionName];
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/engine.io-client/node_modules/ws/lib/sender.js
58187
+ // ../../node_modules/ws/lib/sender.js
57946
58188
  var require_sender = __commonJS({
57947
- "../../node_modules/engine.io-client/node_modules/ws/lib/sender.js"(exports2, module2) {
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 PerMessageDeflate = require_permessage_deflate();
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[PerMessageDeflate.extensionName];
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[PerMessageDeflate.extensionName];
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/engine.io-client/node_modules/ws/lib/event-target.js
58680
+ // ../../node_modules/ws/lib/event-target.js
58434
58681
  var require_event_target = __commonJS({
58435
- "../../node_modules/engine.io-client/node_modules/ws/lib/event-target.js"(exports2, module2) {
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/engine.io-client/node_modules/ws/lib/extension.js
58909
+ // ../../node_modules/ws/lib/extension.js
58663
58910
  var require_extension = __commonJS({
58664
- "../../node_modules/engine.io-client/node_modules/ws/lib/extension.js"(exports2, module2) {
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((extension) => {
58798
- let configurations = extensions[extension];
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 [extension].concat(
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/engine.io-client/node_modules/ws/lib/websocket.js
59062
+ // ../../node_modules/ws/lib/websocket.js
58816
59063
  var require_websocket = __commonJS({
58817
- "../../node_modules/engine.io-client/node_modules/ws/lib/websocket.js"(exports2, module2) {
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 PerMessageDeflate = require_permessage_deflate();
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[PerMessageDeflate.extensionName]) {
59035
- this._extensions[PerMessageDeflate.extensionName].cleanup();
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[PerMessageDeflate.extensionName]) {
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 (e) {
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 PerMessageDeflate(
59370
- opts.perMessageDeflate !== true ? 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
- [PerMessageDeflate.extensionName]: perMessageDeflate.offer()
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] !== PerMessageDeflate.extensionName) {
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[PerMessageDeflate.extensionName]);
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[PerMessageDeflate.extensionName] = perMessageDeflate;
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
- closeTimeout
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
- let chunk;
59662
- if (!this._readableState.endEmitted && !websocket._closeFrameReceived && !websocket._receiver._writableState.errorEmitted && (chunk = websocket._socket.read()) !== null) {
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/engine.io-client/node_modules/ws/lib/stream.js
59958
+ // ../../node_modules/ws/lib/stream.js
59699
59959
  var require_stream = __commonJS({
59700
- "../../node_modules/engine.io-client/node_modules/ws/lib/stream.js"(exports2, module2) {
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/engine.io-client/node_modules/ws/lib/subprotocol.js
60056
+ // ../../node_modules/ws/lib/subprotocol.js
59797
60057
  var require_subprotocol = __commonJS({
59798
- "../../node_modules/engine.io-client/node_modules/ws/lib/subprotocol.js"(exports2, module2) {
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/engine.io-client/node_modules/ws/lib/websocket-server.js
60101
+ // ../../node_modules/ws/lib/websocket-server.js
59842
60102
  var require_websocket_server = __commonJS({
59843
- "../../node_modules/engine.io-client/node_modules/ws/lib/websocket-server.js"(exports2, module2) {
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 extension = require_extension();
59850
- var PerMessageDeflate = require_permessage_deflate();
59851
- var subprotocol = require_subprotocol();
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 = subprotocol.parse(secWebSocketProtocol);
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 PerMessageDeflate(
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 = extension.parse(secWebSocketExtensions);
60087
- if (offers[PerMessageDeflate.extensionName]) {
60088
- perMessageDeflate.accept(offers[PerMessageDeflate.extensionName]);
60089
- extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
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[PerMessageDeflate.extensionName]) {
60161
- const params = extensions[PerMessageDeflate.extensionName].params;
60162
- const value2 = extension.format({
60163
- [PerMessageDeflate.extensionName]: [params]
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.175",
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
- "smol-toml": "^1.6.1",
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: "~5.9.3",
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((extension) => extension.trim()).filter((extension) => [".COM", ".EXE", ".BAT", ".CMD"].includes(extension.toUpperCase()));
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((extension) => extension.toLowerCase())].some(
65663
- (extension) => named.endsWith(extension)
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 extension of extensions) {
65675
- const candidate = (0, import_node_path42.join)(directory, `${command}${extension}`);
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\n|\n|\r/g);
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\n|\n|\r/g);
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/util.js
66429
- function isEscaped(str, ptr) {
66430
- let i = 0;
66431
- while (str[ptr - ++i] === "\\")
66432
- ;
66433
- return --i && i % 2;
66434
- }
66435
- function indexOfNewline(str, start2 = 0, end = str.length) {
66436
- let idx = str.indexOf("\n", start2);
66437
- if (str[idx - 1] === "\r")
66438
- idx--;
66439
- return idx <= end ? idx : -1;
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
- throw new TomlError("cannot find end of structure", {
66484
- toml: str,
66485
- ptr
66486
- });
66487
- }
66488
- function getStringEnd(str, seek) {
66489
- let first = str[seek];
66490
- let target = first === str[seek + 1] && str[seek + 1] === str[seek + 2] ? str.slice(seek, seek + 3) : first;
66491
- seek += target.length - 1;
66492
- do
66493
- seek = str.indexOf(target, ++seek);
66494
- while (seek > -1 && first !== "'" && isEscaped(str, seek));
66495
- if (seek > -1) {
66496
- seek += target.length;
66497
- if (target.length > 1) {
66498
- if (str[seek] === first)
66499
- seek++;
66500
- if (str[seek] === first)
66501
- seek++;
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
- return seek;
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})?[T ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|[-+]\d{2}:\d{2})?$/i;
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
- let match = date5.match(DATE_TIME_RE);
66519
- if (match) {
66520
- if (!match[1]) {
66521
- hasDate = false;
66522
- date5 = `0000-01-01T${date5}`;
66523
- }
66524
- hasTime = !!match[2];
66525
- hasTime && date5[10] === " " && (date5 = date5.replace(" ", "T"));
66526
- if (match[2] && +match[2] > 23) {
66527
- date5 = "";
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
- offset = match[3] || null;
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/primitive.js
66600
- var INT_REGEX = /^((0x[0-9a-fA-F](_?[0-9a-fA-F])*)|(([+-]|0[ob])?\d(_?\d)*))$/;
66601
- var FLOAT_REGEX = /^[+-]?\d(_?\d)*(\.\d(_?\d)*)?([eE][+-]?\d(_?\d)*)?$/;
66602
- var LEADING_ZERO = /^[+-]?0[0-9_]/;
66603
- var ESCAPE_REGEX = /^[0-9a-f]{2,8}$/i;
66604
- var ESC_MAP = {
66605
- b: "\b",
66606
- t: " ",
66607
- n: "\n",
66608
- f: "\f",
66609
- r: "\r",
66610
- e: "\x1B",
66611
- '"': '"',
66612
- "\\": "\\"
66613
- };
66614
- function parseString(str, ptr = 0, endPtr = str.length) {
66615
- let isLiteral = str[ptr] === "'";
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
- return parsed + str.slice(sliceStart, endPtr - 1);
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
- const date5 = new TomlDate(value2);
66729
- if (!date5.isValid()) {
66730
- throw new TomlError("invalid value", {
66731
- toml,
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
- return date5;
66736
- }
66737
-
66738
- // ../../node_modules/smol-toml/dist/extract.js
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
- return [value2.trimEnd(), commentIdx];
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
- let c = str[ptr];
66756
- if (c === "[" || c === "{") {
66757
- let [value2, endPtr2] = c === "[" ? parseArray(str, ptr, depth, integersAsBigInt) : parseInlineTable(str, ptr, depth, integersAsBigInt);
66758
- if (end) {
66759
- endPtr2 = skipVoid(str, endPtr2);
66760
- if (str[endPtr2] === ",")
66761
- endPtr2++;
66762
- else if (str[endPtr2] !== end) {
66763
- throw new TomlError("expected comma or end of structure", {
66764
- toml: str,
66765
- ptr: endPtr2
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
- return [value2, endPtr2];
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
- let endPtr;
66772
- if (c === '"' || c === "'") {
66773
- endPtr = getStringEnd(str, ptr);
66774
- let parsed = parseString(str, ptr, endPtr);
66775
- if (end) {
66776
- endPtr = skipVoid(str, endPtr);
66777
- if (str[endPtr] && str[endPtr] !== "," && str[endPtr] !== end && str[endPtr] !== "\n" && str[endPtr] !== "\r") {
66778
- throw new TomlError("unexpected character encountered", {
66779
- toml: str,
66780
- ptr: endPtr
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
- return [parsed, endPtr];
67125
+ } catch (e) {
67126
+ TomlError.x(e instanceof Error ? e.message : "" + e, ctx, errPtr);
66786
67127
  }
66787
- endPtr = skipUntil(str, ptr, ",", end);
66788
- let slice = sliceAndTrimEndOf(str, ptr, endPtr - +(str[endPtr - 1] === ","));
66789
- if (!slice[0]) {
66790
- throw new TomlError("incomplete key-value declaration: no value specified", {
66791
- toml: str,
66792
- ptr
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
- if (end && slice[1] > -1) {
66796
- endPtr = skipVoid(str, ptr + slice[1]);
66797
- endPtr += +(str[endPtr] === ",");
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
- var KEY_PART_RE = /^[a-zA-Z0-9-_]+[ \t]*$/;
66807
- function parseKey(str, ptr, end = "=") {
66808
- let dot = ptr - 1;
67157
+ function parseKey(ctx, end = 61) {
67158
+ let startPtr;
67159
+ let state = 0;
66809
67160
  let parsed = [];
66810
- let endPtr = str.indexOf(end, ptr);
66811
- if (endPtr < 0) {
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
- let c = str[ptr = ++dot];
66819
- if (c !== " " && c !== " ") {
66820
- if (c === '"' || c === "'") {
66821
- if (c === str[ptr + 1] && c === str[ptr + 2]) {
66822
- throw new TomlError("multiline strings are not allowed in keys", {
66823
- toml: str,
66824
- ptr
66825
- });
66826
- }
66827
- let eos = getStringEnd(str, ptr);
66828
- if (eos < 0) {
66829
- throw new TomlError("unfinished string encountered", {
66830
- toml: str,
66831
- ptr
66832
- });
66833
- }
66834
- dot = str.indexOf(".", eos);
66835
- let strEnd = str.slice(eos, dot < 0 || dot > endPtr ? endPtr : dot);
66836
- let newLine = indexOfNewline(strEnd);
66837
- if (newLine > -1) {
66838
- throw new TomlError("newlines are not allowed in keys", {
66839
- toml: str,
66840
- ptr: ptr + dot + newLine
66841
- });
66842
- }
66843
- if (strEnd.trimStart()) {
66844
- throw new TomlError("found extra tokens after the string part", {
66845
- toml: str,
66846
- ptr: eos
66847
- });
66848
- }
66849
- if (endPtr < eos) {
66850
- endPtr = str.indexOf(end, eos);
66851
- if (endPtr < 0) {
66852
- throw new TomlError("incomplete key-value: cannot find end of key", {
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
- ptr++;
66879
- while ((c = str[ptr++]) !== "}" && c) {
66880
- if (c === ",") {
66881
- throw new TomlError("expected value, found comma", {
66882
- toml: str,
66883
- ptr: ptr - 1
66884
- });
66885
- } else if (c === "#")
66886
- ptr = skipComment(str, ptr);
66887
- else if (c !== " " && c !== " " && c !== "\n" && c !== "\r") {
66888
- let k;
66889
- let t = res;
66890
- let hasOwn = false;
66891
- let [key, keyEndPtr] = parseKey(str, ptr - 1);
66892
- for (let i = 0; i < key.length; i++) {
66893
- if (i)
66894
- t = hasOwn ? t[k] : t[k] = {};
66895
- k = key[i];
66896
- if ((hasOwn = Object.hasOwn(t, k)) && (typeof t[k] !== "object" || seen.has(t[k]))) {
66897
- throw new TomlError("trying to redefine an already defined value", {
66898
- toml: str,
66899
- ptr
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
- throw new TomlError("trying to redefine an already defined value", {
66908
- toml: str,
66909
- ptr
66910
- });
67224
+ if (!hasOwn && unsafe) {
67225
+ Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
66911
67226
  }
66912
- let [value2, valueEndPtr] = extractValue(str, keyEndPtr, "}", depth - 1, integersAsBigInt);
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
- t[k] = value2;
66915
- ptr = valueEndPtr;
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
- if (!c) {
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(str, ptr, depth, integersAsBigInt) {
67248
+ function parseArray(ctx) {
67249
+ let startPtr = ctx.p++;
66927
67250
  let res = [];
66928
67251
  let c;
66929
- ptr++;
66930
- while ((c = str[ptr++]) !== "]" && c) {
66931
- if (c === ",") {
66932
- throw new TomlError("expected value, found comma", {
66933
- toml: str,
66934
- ptr: ptr - 1
66935
- });
66936
- } else if (c === "#")
66937
- ptr = skipComment(str, ptr);
66938
- else if (c !== " " && c !== " " && c !== "\n" && c !== "\r") {
66939
- let e = extractValue(str, ptr - 1, "]", depth - 1, integersAsBigInt);
66940
- res.push(e[0]);
66941
- ptr = e[1];
66942
- }
66943
- }
66944
- if (!c) {
66945
- throw new TomlError("unfinished array encountered", {
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
- return [res, ptr];
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
- if (k === "__proto__") {
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 parse3(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
67014
- let res = {};
67015
- let meta3 = {};
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
- for (let ptr = skipVoid(toml, 0); ptr < toml.length; ) {
67019
- if (toml[ptr] === "[") {
67020
- let isTableArray = toml[++ptr] === "[";
67021
- let k = parseKey(toml, ptr += +isTableArray, "]");
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[k[1] - 1] !== "]") {
67024
- throw new TomlError("expected end of table declaration", {
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
- k[1]++;
67372
+ ctx.p++;
67030
67373
  }
67031
67374
  let p = peekTable(
67032
- k[0],
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
- throw new TomlError("trying to redefine an already defined table or value", {
67040
- toml,
67041
- ptr
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
- let k = parseKey(toml, ptr);
67390
+ tmp = ctx.p;
67391
+ let k = parseKey(ctx);
67049
67392
  let p = peekTable(
67050
- k[0],
67393
+ ctx,
67394
+ k,
67051
67395
  tbl,
67052
67396
  m,
67053
67397
  0
67054
67398
  /* Type.DOTTED */
67055
67399
  );
67056
- if (!p) {
67057
- throw new TomlError("trying to redefine an already defined table or value", {
67058
- toml,
67059
- ptr
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
- ptr = skipVoid(toml, ptr, true);
67067
- if (toml[ptr] && toml[ptr] !== "\n" && toml[ptr] !== "\r") {
67068
- throw new TomlError("each key-value declaration must be followed by an end-of-line", {
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
- ptr = skipVoid(toml, ptr);
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 JSON.stringify(s).replace(/\x7f/g, "\\u007f");
67454
+ return formatWellFormedStringUnchecked(HAS_WELLFORMED ? s.toWellFormed() : s);
67099
67455
  }
67100
- function stringifyValue(val, type, depth, numberAsFloat) {
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
- if (type === "number") {
67105
- if (isNaN(val))
67106
- return "nan";
67107
- if (val === Infinity)
67108
- return "inf";
67109
- if (val === -Infinity)
67110
- return "-inf";
67111
- if (numberAsFloat && Number.isInteger(val))
67112
- return val.toFixed(1);
67113
- return val.toString();
67114
- }
67115
- if (type === "bigint" || type === "boolean") {
67116
- return val.toString();
67117
- }
67118
- if (type === "string") {
67119
- return formatString(val);
67120
- }
67121
- if (type === "date") {
67122
- if (isNaN(val.getTime())) {
67123
- throw new TypeError("cannot serialize invalid date");
67124
- }
67125
- return val.toISOString();
67126
- }
67127
- if (type === "object") {
67128
- return stringifyInlineTable(val, depth, numberAsFloat);
67129
- }
67130
- if (type === "array") {
67131
- return stringifyArray(val, depth, numberAsFloat);
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 += BARE_KEY.test(k) ? k : formatString(k);
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 = BARE_KEY.test(k) ? k : formatString(k);
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 extension = import_node_path62.posix.extname(path4).toLowerCase();
71071
- if (IMAGE_EXTENSIONS2.has(extension)) return "image";
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(extension)) return "markdown";
71074
- if (CODE_EXTENSIONS.has(extension) || path4.startsWith("scripts/")) return "code";
71075
- if (TEXT_EXTENSIONS.has(extension) || looksLikeUtf8Text(bytes)) return "text";
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 (!busy.has(runId)) await markInterrupted(runId);
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/engine.io-client/node_modules/ws/wrapper.mjs
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: