refactor: remove AI agent module and related configurations
ZhenYi committed
Deleted app/ai/src/main.rs app/ai/src/main.rs +0 −81
@@ -1,81 +0,0 @@
1use anyhow::Context;
2use config::scoped::{AiConfig, ScopedConfig};
3use tracing::{info, warn};
4
5mod worker;
6
7#[tokio::main]
8async fn main() -> anyhow::Result<()> {
9 init_tracing();
10
11 let cfg = AiConfig::load().context("loading configuration")?;
12 anyhow::ensure!(cfg.agent.is_enabled(), "agent configuration is not enabled");
13 anyhow::ensure!(cfg.nats.is_enabled(), "nats url must be set");
14
15 info!("connecting to database / redis / storage / nats");
16 let queue = cfg.agent.queue.clone();
17 let state = export::AppState::with_config(cfg.clone().into_app_config())
18 .await
19 .context("building app state")?;
20 let runtime =
21 agent::runtime::AgentRuntime::new(state.clone()).map_err(|e| anyhow::anyhow!(e))?;
22 let nats = export::AppNats::connect(&cfg.nats)
23 .await
24 .context("connecting to nats")?;
25 info!("dependencies ready");
26
27 let running = worker::start(state, runtime, nats, queue.clone())
28 .await
29 .context("starting ai worker")?;
30 info!(
31 concurrency = queue.concurrency,
32 subject = %queue.subject,
33 "ai worker running"
34 );
35
36 wait_for_shutdown().await;
37 info!("ai worker shutting down");
38
39 running
40 .shutdown()
41 .await
42 .map_err(|e| anyhow::anyhow!("worker shutdown: {e}"))?;
43
44 info!("ai worker shut down");
45 Ok(())
46}
47
48fn init_tracing() {
49 use tracing_subscriber::EnvFilter;
50 let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info"));
51 tracing_subscriber::fmt().with_env_filter(filter).init();
52}
53
54async fn wait_for_shutdown() {
55 let ctrl_c = async {
56 if let Err(err) = tokio::signal::ctrl_c().await {
57 warn!(error = %err, "failed to install ctrl_c handler");
58 }
59 };
60
61 #[cfg(unix)]
62 let terminate = async {
63 use tokio::signal::unix::{SignalKind, signal};
64 match signal(SignalKind::terminate()) {
65 Ok(mut s) => {
66 s.recv().await;
67 }
68 Err(err) => {
69 warn!(error = %err, "failed to install SIGTERM handler");
70 }
71 }
72 };
73
74 #[cfg(not(unix))]
75 let terminate = std::future::pending::<()>();
76
77 tokio::select! {
78 _ = ctrl_c => info!("received SIGINT"),
79 _ = terminate => info!("received SIGTERM"),
80 }
81}
Deleted app/ai/src/worker.rs app/ai/src/worker.rs +0 −255
@@ -1,255 +0,0 @@
1use std::collections::HashSet;
2use std::sync::Arc;
3use std::time::Duration;
4
5use agent::runtime::{AgentRuntime, RunTask, RuntimeConfig, sweep};
6use anyhow::Context;
7use async_nats::jetstream::consumer::{self, AckPolicy, pull};
8use async_nats::jetstream::{AckKind, Message, stream};
9use config::agent::AgentQueueConfig;
10use export::{AppNats, AppState};
11use futures::StreamExt;
12use models::agent::run::{self, AgentRunState};
13use sea_orm::EntityTrait;
14use tokio::sync::{Mutex, OwnedSemaphorePermit, Semaphore};
15use tokio::task::JoinSet;
16use tokio_util::sync::CancellationToken;
17use tracing::{info, warn};
18use uuid::Uuid;
19
20type PullConsumer = consumer::Consumer<pull::Config>;
21
22pub struct RunningWorker {
23 cancel: CancellationToken,
24 consume: tokio::task::JoinHandle<anyhow::Result<()>>,
25 reaper: tokio::task::JoinHandle<()>,
26}
27
28impl RunningWorker {
29 pub async fn shutdown(self) -> anyhow::Result<()> {
30 self.cancel.cancel();
31 let consume = self.consume.await;
32 let _ = self.reaper.await;
33 match consume {
34 Ok(result) => result.context("consume loop"),
35 Err(err) => Err(anyhow::anyhow!("consume loop panicked: {err}")),
36 }
37 }
38}
39
40pub async fn start(
41 state: AppState,
42 runtime: AgentRuntime,
43 nats: AppNats,
44 queue: AgentQueueConfig,
45) -> anyhow::Result<RunningWorker> {
46 let js = nats.jetstream();
47 let stream = js
48 .get_or_create_stream(stream::Config {
49 name: queue.stream.clone(),
50 subjects: vec![queue.subject.clone()],
51 storage: stream::StorageType::File,
52 max_age: Duration::from_secs(queue.stream_max_age_secs),
53 ..Default::default()
54 })
55 .await
56 .map_err(|e| anyhow::anyhow!("creating stream {}: {e}", queue.stream))?;
57 let consumer = stream
58 .get_or_create_consumer(
59 &queue.durable,
60 pull::Config {
61 durable_name: Some(queue.durable.clone()),
62 ack_policy: AckPolicy::Explicit,
63 ack_wait: Duration::from_secs(queue.ack_wait_secs),
64 max_deliver: queue.max_deliver,
65 ..Default::default()
66 },
67 )
68 .await
69 .map_err(|e| anyhow::anyhow!("creating consumer {}: {e}", queue.durable))?;
70
71 let cancel = CancellationToken::new();
72 let inflight: Arc<Mutex<HashSet<Uuid>>> = Arc::new(Mutex::new(HashSet::new()));
73 let runtime_config = runtime.config().clone();
74 let consume = tokio::spawn(consume_loop(
75 state.clone(),
76 runtime,
77 consumer,
78 queue.clone(),
79 inflight.clone(),
80 cancel.clone(),
81 ));
82 let reaper = tokio::spawn(reaper_loop(
83 state,
84 runtime_config,
85 Duration::from_secs(queue.sweep_interval_secs),
86 cancel.clone(),
87 ));
88 Ok(RunningWorker {
89 cancel,
90 consume,
91 reaper,
92 })
93}
94
95async fn consume_loop(
96 state: AppState,
97 runtime: AgentRuntime,
98 consumer: PullConsumer,
99 queue: AgentQueueConfig,
100 inflight: Arc<Mutex<HashSet<Uuid>>>,
101 cancel: CancellationToken,
102) -> anyhow::Result<()> {
103 let semaphore = Arc::new(Semaphore::new(queue.concurrency));
104 let nak_delay = Duration::from_secs(queue.nak_delay_secs);
105 let mut tasks: JoinSet<()> = JoinSet::new();
106
107 'outer: loop {
108 let mut messages = tokio::select! {
109 result = consumer.messages() => {
110 result.map_err(|e| anyhow::anyhow!("opening consumer stream: {e}"))?
111 }
112 _ = cancel.cancelled() => break 'outer,
113 };
114 loop {
115 let message = tokio::select! {
116 _ = cancel.cancelled() => break 'outer,
117 item = messages.next() => item,
118 };
119 match message {
120 Some(Ok(message)) => {
121 let permit = tokio::select! {
122 permit = semaphore.clone().acquire_owned() => permit,
123 _ = cancel.cancelled() => break 'outer,
124 };
125 let permit = permit.map_err(|e| anyhow::anyhow!(e.to_string()))?;
126 tasks.spawn(handle_message(
127 state.clone(),
128 runtime.clone(),
129 message,
130 permit,
131 inflight.clone(),
132 nak_delay,
133 ));
134 }
135 Some(Err(err)) => {
136 warn!(%err, "consumer stream error, reopening");
137 break;
138 }
139 None => {
140 warn!("consumer stream ended, reopening");
141 break;
142 }
143 }
144 }
145 tokio::select! {
146 _ = cancel.cancelled() => break 'outer,
147 _ = tokio::time::sleep(Duration::from_secs(5)) => {}
148 }
149 }
150
151 let ids: Vec<Uuid> = inflight.lock().await.iter().copied().collect();
152 for run_id in ids {
153 if let Err(err) = runtime.request_cancel(run_id).await {
154 warn!(%run_id, %err, "failed to request cancel during drain");
155 }
156 }
157 let drain = async {
158 while let Some(result) = tasks.join_next().await {
159 if let Err(err) = result {
160 warn!(%err, "run task panicked during drain");
161 }
162 }
163 };
164 if tokio::time::timeout(Duration::from_secs(queue.drain_timeout_secs), drain)
165 .await
166 .is_err()
167 {
168 warn!("drain timeout exceeded, aborting in-flight run tasks");
169 tasks.abort_all();
170 while tasks.join_next().await.is_some() {}
171 }
172 Ok(())
173}
174
175async fn handle_message(
176 state: AppState,
177 runtime: AgentRuntime,
178 message: Message,
179 _permit: OwnedSemaphorePermit,
180 inflight: Arc<Mutex<HashSet<Uuid>>>,
181 nak_delay: Duration,
182) {
183 let task: RunTask = match serde_json::from_slice(&message.message.payload) {
184 Ok(task) => task,
185 Err(err) => {
186 warn!(%err, "dropping malformed agent task message");
187 let _ = message.ack().await;
188 return;
189 }
190 };
191 let run_id = task.run_id;
192 inflight.lock().await.insert(run_id);
193 info!(%run_id, "executing agent run");
194 let nak = match runtime.execute(run_id).await {
195 Ok(outcome) => {
196 info!(
197 %run_id,
198 state = ?outcome.state,
199 stop_reason = ?outcome.stop_reason,
200 "agent run finished"
201 );
202 false
203 }
204 Err(err) => {
205 warn!(%run_id, %err, "agent run execution failed");
206 should_retry(&state, run_id).await
207 }
208 };
209 if nak {
210 let _ = message.ack_with(AckKind::Nak(Some(nak_delay))).await;
211 } else {
212 let _ = message.ack().await;
213 }
214 inflight.lock().await.remove(&run_id);
215}
216
217async fn should_retry(state: &AppState, run_id: Uuid) -> bool {
218 match run::Entity::find_by_id(run_id)
219 .one(state.database.write())
220 .await
221 {
222 Ok(Some(row)) => row.state == AgentRunState::Queued,
223 _ => false,
224 }
225}
226
227async fn reaper_loop(
228 state: AppState,
229 config: RuntimeConfig,
230 interval: Duration,
231 cancel: CancellationToken,
232) {
233 let mut ticker = tokio::time::interval(interval);
234 loop {
235 tokio::select! {
236 _ = cancel.cancelled() => break,
237 _ = ticker.tick() => {
238 match sweep(&state, &config).await {
239 Ok(report) => {
240 if report.killed + report.lost + report.orphaned + report.failed_runs > 0 {
241 info!(
242 killed = report.killed,
243 lost = report.lost,
244 orphaned = report.orphaned,
245 failed_runs = report.failed_runs,
246 "reaper sweep"
247 );
248 }
249 }
250 Err(err) => warn!(%err, "reaper sweep failed"),
251 }
252 }
253 }
254 }
255}
Deleted app/ai/Cargo.toml app/ai/Cargo.toml +0 −21
@@ -1,21 +0,0 @@
1[package]
2name = "ai"
3version.workspace = true
4edition.workspace = true
5publish = false
6
7[dependencies]
8agent = { workspace = true }
9config = { workspace = true }
10export = { workspace = true }
11models = { workspace = true }
12async-nats = { workspace = true }
13sea-orm = { workspace = true }
14tokio = { workspace = true, features = ["signal", "rt-multi-thread", "macros", "time"] }
15tokio-util = { workspace = true }
16futures = { workspace = true }
17serde_json = { workspace = true }
18tracing = { workspace = true }
19tracing-subscriber = { workspace = true }
20anyhow = { workspace = true }
21uuid = { workspace = true }
Deleted chart/templates/ai.yaml chart/templates/ai.yaml +0 −52
@@ -1,52 +0,0 @@
1{{- if .Values.ai.enabled }}
2apiVersion: apps/v1
3kind: Deployment
4metadata:
5 name: {{ printf "%s-ai" (include "gitdata.fullname" .) }}
6 labels:
7 {{- include "gitdata.labels" . | nindent 4 }}
8 app.kubernetes.io/component: ai
9spec:
10 replicas: {{ .Values.ai.replicaCount }}
11 revisionHistoryLimit: 3
12 selector:
13 matchLabels:
14 {{- include "gitdata.selectorLabels" . | nindent 6 }}
15 app.kubernetes.io/component: ai
16 template:
17 metadata:
18 labels:
19 {{- include "gitdata.selectorLabels" . | nindent 8 }}
20 app.kubernetes.io/component: ai
21 {{- with .Values.podLabels }}
22 {{- toYaml . | nindent 8 }}
23 {{- end }}
24 annotations:
25 checksum/env: {{ toYaml .Values.config.env | sha256sum }}
26 {{- with .Values.podAnnotations }}
27 {{- toYaml . | nindent 8 }}
28 {{- end }}
29 spec:
30 serviceAccountName: {{ include "gitdata.serviceAccountName" . }}
31 {{- include "gitdata.imagePullSecrets" . | nindent 6 }}
32 # 停机时取消并排空在飞 run（drain_timeout 120s + 余量）
33 terminationGracePeriodSeconds: 300
34 securityContext:
35 {{- toYaml .Values.podSecurityContext | nindent 8 }}
36 containers:
37 - name: ai
38 image: {{ include "gitdata.image" . }}
39 imagePullPolicy: {{ .Values.image.pullPolicy }}
40 args: ["ai"]
41 {{- include "gitdata.envFrom" . | nindent 10 }}
42 env:
43 {{- include "gitdata.env" . | nindent 12 }}
44 {{- with .Values.ai.extraEnv }}
45 {{- toYaml . | nindent 12 }}
46 {{- end }}
47 # 无监听端口（NATS JetStream worker），不做端口探针；执行全在 cubesandbox，不挂 repos PVC
48 securityContext:
49 {{- toYaml .Values.securityContext | nindent 12 }}
50 resources:
51 {{- toYaml .Values.ai.resources | nindent 12 }}
52{{- end }}
Modified chart/templates/NOTES.txt chart/templates/NOTES.txt +0 −3 View chart/templates/NOTES.txt
@@ -23,6 +23,3 @@
2323 生产环境建议 --set secret.existingSecret=<name> 并用外部 Secret 管理。
2424 - repos PVC 需 RWX（NFS/CephFS/EFS）；无 RWX 时将 githost/synchost 各缩到 1 副本并固定同节点。
2525 - 磁盘上的 config/local.toml 含真实密钥，部署前请轮换。
26{{- if .Values.ai.enabled }}
27 - ai worker 需要外部 NATS（APP_NATS__URL）与 APP_AGENT__* provider/sandbox 配置，缺一启动即失败。
28{{- end }}
Modified chart/Chart.yaml chart/Chart.yaml +1 −1 View chart/Chart.yaml
@@ -1,6 +1,6 @@
11apiVersion: v2
22name: gitdata
3description: GitData — Rust workspace (apihost / githost / synchost / mails / migrate / ai)
3description: GitData — Rust workspace (apihost / githost / synchost / mails / migrate)
44type: application
55version: 0.1.0
66appVersion: "1.0.0"
Modified chart/values.yaml chart/values.yaml +0 −10 View chart/values.yaml
@@ -139,16 +139,6 @@
139139 limits: { memory: 256Mi }
140140 extraEnv: []
141141
142# AI agent worker：消费 NATS JetStream 任务并执行 agent run。
143# 依赖外部 NATS（APP_NATS__URL）与 [agent] 配置就绪，故默认关闭。
144ai:
145 enabled: false
146 replicaCount: 1
147 resources:
148 requests: { cpu: 200m, memory: 256Mi }
149 limits: { memory: 1Gi }
150 extraEnv: []
151
152142# ---------------------------------------------------------------------------
153143# 存储：githost 与 synchost 共享 bare 仓库，需要 RWX
154144# ---------------------------------------------------------------------------
Modified config/default.toml config/default.toml +0 −42 View config/default.toml
@@ -16,12 +16,6 @@
1616username = ""
1717password = ""
1818
19[nats]
20url = ""
21token = ""
22user = ""
23password = ""
24
2519[cache]
2620l1_capacity = 10000
2721l1_ttl_secs = 0
@@ -254,39 +248,3 @@
254248enabled = true
255249http_bind_addr = "0.0.0.0"
256250http_port = 9418
257
258[agent]
259
260[agent.provider]
261base_url = ""
262api_key = ""
263model = ""
264
265[agent.sandbox]
266api_url = ""
267api_key = ""
268template_id = ""
269timeout_secs = 3600
270lease_secs = 600
271
272[agent.runtime]
273default_max_turns = 32
274event_stream_maxlen = 10000
275event_ttl_secs = 86400
276tool_output_max_bytes = 32768
277artifact_max_size = 104857600
278artifact_dir = ""
279context_max_tokens = 128000
280compact_keep_recent = 16
281
282[agent.queue]
283stream = "AGENT"
284subject = "agent.run.execute"
285durable = "ai-executor"
286concurrency = 4
287ack_wait_secs = 7200
288max_deliver = 8
289nak_delay_secs = 30
290drain_timeout_secs = 120
291sweep_interval_secs = 300
292stream_max_age_secs = 86400
Deleted lib/agent/src/runtime/compact.rs lib/agent/src/runtime/compact.rs +0 −263
@@ -1,263 +0,0 @@
1use rig::client::CompletionClient;
2use rig::completion::message::{AssistantContent, ToolResultContent, UserContent};
3use rig::completion::{CompletionModel, Message};
4use rig::providers::openai::CompletionsClient;
5
6use super::events::CompactMethod;
7
8pub const CHARS_PER_TOKEN: usize = 4;
9
10const PER_MESSAGE_OVERHEAD_TOKENS: usize = 4;
11const TOOL_RESULT_RENDER_MAX_CHARS: usize = 2_000;
12const TOOL_CALL_ARGS_RENDER_MAX_CHARS: usize = 500;
13const SUMMARY_PREFIX: &str = "[Summary of earlier conversation]";
14const TRUNCATE_MARKER: &str = "[Earlier messages were truncated to fit the context window]";
15
16const SUMMARY_INSTRUCTION: &str = "You are a conversation compactor for an autonomous engineering agent. \
17Summarize the transcript of the earlier conversation between the user, the assistant and its sandbox tools. \
18Preserve exactly: the original task goal and constraints; key decisions and their rationale; every file path, command, sandbox id, artifact name and identifier later steps may need; what has been completed and verified; what remains to be done next. \
19Be dense and factual, prefer bullet lists, no commentary. Output only the summary.";
20
21pub struct Compaction {
22 pub history: Vec<Message>,
23 pub method: CompactMethod,
24 pub before: usize,
25 pub after: usize,
26 pub estimated_tokens: usize,
27 pub summary: Option<String>,
28 pub prefix_len: usize,
29}
30
31#[derive(Clone)]
32pub struct Summarizer {
33 client: CompletionsClient,
34 model: String,
35}
36
37impl Summarizer {
38 pub fn new(client: CompletionsClient, model: String) -> Self {
39 Self { client, model }
40 }
41
42 pub async fn summarize(&self, transcript: &str) -> std::result::Result<String, String> {
43 let response = self
44 .client
45 .completion_model(self.model.clone())
46 .completion_request(Message::user(transcript.to_string()))
47 .preamble(SUMMARY_INSTRUCTION.to_string())
48 .send()
49 .await
50 .map_err(|e| e.to_string())?;
51 let text: String = response
52 .choice
53 .iter()
54 .filter_map(|c| match c {
55 AssistantContent::Text(t) => Some(t.text.as_str()),
56 _ => None,
57 })
58 .collect::<Vec<_>>()
59 .join("");
60 let text = text.trim();
61 if text.is_empty() {
62 return Err("model returned an empty summary".to_string());
63 }
64 Ok(text.to_string())
65 }
66}
67
68pub fn estimate_message_tokens(message: &Message) -> usize {
69 let chars = serde_json::to_string(message)
70 .map(|s| s.len())
71 .unwrap_or(4 * CHARS_PER_TOKEN);
72 chars / CHARS_PER_TOKEN + PER_MESSAGE_OVERHEAD_TOKENS
73}
74
75pub fn estimate_tokens(history: &[Message]) -> usize {
76 history.iter().map(estimate_message_tokens).sum()
77}
78
79pub fn trigger_threshold(context_max_tokens: usize) -> usize {
80 context_max_tokens * 3 / 4
81}
82
83pub fn summary_message(summary: &str) -> Message {
84 Message::user(format!("{SUMMARY_PREFIX}\n{summary}"))
85}
86
87pub(crate) fn starts_with_tool_result(message: &Message) -> bool {
88 matches!(
89 message,
90 Message::User { content }
91 if content
92 .iter()
93 .any(|c| matches!(c, UserContent::ToolResult(_)))
94 )
95}
96
97pub fn safe_split(history: &[Message], keep_recent: usize) -> (&[Message], &[Message]) {
98 let len = history.len();
99 if len <= keep_recent {
100 return (&[], history);
101 }
102 let mut cut = len - keep_recent;
103 while cut > 0 && starts_with_tool_result(&history[cut]) {
104 cut -= 1;
105 }
106 (&history[..cut], &history[cut..])
107}
108
109pub async fn compact_history(
110 summarizer: &Summarizer,
111 history: Vec<Message>,
112 budget_tokens: usize,
113 keep_recent: usize,
114) -> Compaction {
115 let before = history.len();
116 let (prefix, tail) = safe_split(&history, keep_recent);
117 if prefix.is_empty() {
118 let (truncated, dropped) = truncate_to_budget(&history, budget_tokens);
119 let estimated_tokens = estimate_tokens(&truncated);
120 let after = truncated.len();
121 return Compaction {
122 history: truncated,
123 method: CompactMethod::Truncate,
124 before,
125 after,
126 estimated_tokens,
127 summary: None,
128 prefix_len: dropped,
129 };
130 }
131
132 let transcript = render_transcript(prefix, budget_tokens * CHARS_PER_TOKEN);
133 match summarizer.summarize(&transcript).await {
134 Ok(summary) => {
135 let tail_len = tail.len();
136 let mut compacted = Vec::with_capacity(tail_len + 1);
137 compacted.push(summary_message(&summary));
138 compacted.extend(tail.iter().cloned());
139 if estimate_tokens(&compacted) > budget_tokens {
140 let (truncated, _) = truncate_to_budget(&compacted, budget_tokens);
141 compacted = truncated;
142 }
143 let estimated_tokens = estimate_tokens(&compacted);
144 let after = compacted.len();
145 Compaction {
146 history: compacted,
147 method: CompactMethod::Summary,
148 before,
149 after,
150 estimated_tokens,
151 summary: Some(summary),
152 prefix_len: before - tail_len,
153 }
154 }
155 Err(e) => {
156 tracing::warn!(error = %e, "history summarization failed, falling back to truncation");
157 let (truncated, dropped) = truncate_to_budget(&history, budget_tokens);
158 let estimated_tokens = estimate_tokens(&truncated);
159 let after = truncated.len();
160 Compaction {
161 history: truncated,
162 method: CompactMethod::Truncate,
163 before,
164 after,
165 estimated_tokens,
166 summary: None,
167 prefix_len: dropped,
168 }
169 }
170 }
171}
172
173pub fn truncate_to_budget(history: &[Message], budget_tokens: usize) -> (Vec<Message>, usize) {
174 let marker = Message::user(TRUNCATE_MARKER);
175 let marker_tokens = estimate_message_tokens(&marker);
176 let mut start = 0;
177 loop {
178 let kept_estimate = estimate_tokens(&history[start..]) + marker_tokens;
179 if kept_estimate <= budget_tokens || start >= history.len() {
180 let mut out = Vec::with_capacity(history.len() - start + 1);
181 out.push(marker);
182 out.extend_from_slice(&history[start..]);
183 return (out, start);
184 }
185 start += 1;
186 while start < history.len() && starts_with_tool_result(&history[start]) {
187 start += 1;
188 }
189 }
190}
191
192pub fn render_transcript(messages: &[Message], max_chars: usize) -> String {
193 let mut lines: Vec<String> = Vec::with_capacity(messages.len());
194 for message in messages {
195 match message {
196 Message::System { content } => lines.push(format!("[system] {content}")),
197 Message::User { content } => {
198 for part in content {
199 match part {
200 UserContent::Text(t) => lines.push(format!("[user] {}", t.text)),
201 UserContent::ToolResult(r) => {
202 let body = render_tool_result(&r.content);
203 lines.push(format!("[tool_result {}] {body}", r.name));
204 }
205 _ => lines.push("[user] [non-text content]".to_string()),
206 }
207 }
208 }
209 Message::Assistant { content, .. } => {
210 for part in content {
211 match part {
212 AssistantContent::Text(t) => {
213 lines.push(format!("[assistant] {}", t.text));
214 }
215 AssistantContent::ToolCall(tc) => {
216 let args = tc.function.arguments.to_string();
217 let args = truncate_chars(&args, TOOL_CALL_ARGS_RENDER_MAX_CHARS);
218 lines.push(format!("[tool_call {}] {args}", tc.function.name));
219 }
220 AssistantContent::Reasoning(_) => {
221 lines.push("[assistant] [reasoning]".to_string());
222 }
223 _ => lines.push("[assistant] [non-text content]".to_string()),
224 }
225 }
226 }
227 }
228 }
229 let full = lines.join("\n");
230 if full.len() <= max_chars {
231 return full;
232 }
233 let mut start = full.len() - max_chars;
234 while start < full.len() && !full.is_char_boundary(start) {
235 start += 1;
236 }
237 format!("[transcript truncated]\n{}", &full[start..])
238}
239
240fn render_tool_result(content: &[ToolResultContent]) -> String {
241 let mut out = String::new();
242 for part in content {
243 match part {
244 ToolResultContent::Text(t) => out.push_str(&t.text),
245 ToolResultContent::Json { value } => out.push_str(&value.to_string()),
246 _ => out.push_str("[non-text content]"),
247 }
248 }
249 truncate_chars(&out, TOOL_RESULT_RENDER_MAX_CHARS)
250}
251
252fn truncate_chars(s: &str, max_chars: usize) -> String {
253 if s.len() <= max_chars {
254 return s.to_string();
255 }
256 let mut end = max_chars;
257 while end > 0 && !s.is_char_boundary(end) {
258 end -= 1;
259 }
260 let mut out = s[..end].to_string();
261 out.push('…');
262 out
263}
Deleted lib/agent/src/runtime/config.rs lib/agent/src/runtime/config.rs +0 −140
@@ -1,140 +0,0 @@
1use std::time::Duration;
2
3use config::agent::AgentConfig;
4
5use crate::error::{AgentError, Result};
6
7#[derive(Clone, Debug)]
8pub struct ProviderSettings {
9 pub base_url: String,
10 pub api_key: String,
11 pub model: String,
12}
13
14#[derive(Clone, Debug)]
15pub struct SandboxSettings {
16 pub api_url: String,
17 pub api_key: String,
18 pub template_id: String,
19 pub timeout: Duration,
20 pub lease: Duration,
21}
22
23#[derive(Clone, Debug)]
24pub struct Limits {
25 pub default_max_turns: usize,
26 pub event_stream_maxlen: u64,
27 pub event_ttl_secs: u64,
28 pub tool_output_max_bytes: usize,
29 pub artifact_max_size: i64,
30 pub artifact_dir: String,
31 pub context_max_tokens: usize,
32 pub compact_keep_recent: usize,
33}
34
35#[derive(Clone, Debug)]
36pub struct RuntimeConfig {
37 pub provider: ProviderSettings,
38 pub sandbox: SandboxSettings,
39 pub limits: Limits,
40}
41
42impl From<&AgentConfig> for RuntimeConfig {
43 fn from(cfg: &AgentConfig) -> Self {
44 Self {
45 provider: ProviderSettings {
46 base_url: cfg.provider.base_url.clone(),
47 api_key: cfg.provider.api_key.clone(),
48 model: cfg.provider.model.clone(),
49 },
50 sandbox: SandboxSettings {
51 api_url: cfg.sandbox.api_url.clone(),
52 api_key: cfg.sandbox.api_key.clone(),
53 template_id: cfg.sandbox.template_id.clone(),
54 timeout: Duration::from_secs(cfg.sandbox.timeout_secs),
55 lease: Duration::from_secs(cfg.sandbox.lease_secs),
56 },
57 limits: Limits {
58 default_max_turns: cfg.runtime.default_max_turns,
59 event_stream_maxlen: cfg.runtime.event_stream_maxlen,
60 event_ttl_secs: cfg.runtime.event_ttl_secs,
61 tool_output_max_bytes: cfg.runtime.tool_output_max_bytes,
62 artifact_max_size: cfg.runtime.artifact_max_size,
63 artifact_dir: cfg.runtime.artifact_dir.clone(),
64 context_max_tokens: cfg.runtime.context_max_tokens,
65 compact_keep_recent: cfg.runtime.compact_keep_recent,
66 },
67 }
68 }
69}
70
71impl RuntimeConfig {
72 pub fn validate(&self) -> Result<()> {
73 if self.provider.base_url.is_empty() {
74 return Err(AgentError::Config(
75 "agent provider base_url must be set".to_string(),
76 ));
77 }
78 if self.provider.model.is_empty() {
79 return Err(AgentError::Config(
80 "agent provider model must be set".to_string(),
81 ));
82 }
83 if self.sandbox.api_url.is_empty() {
84 return Err(AgentError::Config(
85 "agent sandbox api_url must be set".to_string(),
86 ));
87 }
88 if self.sandbox.api_key.is_empty() {
89 return Err(AgentError::Config(
90 "agent sandbox api_key must be set".to_string(),
91 ));
92 }
93 if self.sandbox.template_id.is_empty() {
94 return Err(AgentError::Config(
95 "agent sandbox template_id must be set".to_string(),
96 ));
97 }
98 if self.sandbox.lease.is_zero() || self.sandbox.timeout.is_zero() {
99 return Err(AgentError::Config(
100 "agent sandbox timeouts must be positive".to_string(),
101 ));
102 }
103 if self.sandbox.lease > self.sandbox.timeout {
104 return Err(AgentError::Config(
105 "agent sandbox lease must not exceed timeout".to_string(),
106 ));
107 }
108 if self.limits.default_max_turns == 0 {
109 return Err(AgentError::Config(
110 "agent default_max_turns must be positive".to_string(),
111 ));
112 }
113 if self.limits.event_stream_maxlen == 0 {
114 return Err(AgentError::Config(
115 "agent event_stream_maxlen must be positive".to_string(),
116 ));
117 }
118 if self.limits.tool_output_max_bytes == 0 {
119 return Err(AgentError::Config(
120 "agent tool_output_max_bytes must be positive".to_string(),
121 ));
122 }
123 if self.limits.artifact_max_size <= 0 {
124 return Err(AgentError::Config(
125 "agent artifact_max_size must be positive".to_string(),
126 ));
127 }
128 if self.limits.context_max_tokens == 0 {
129 return Err(AgentError::Config(
130 "agent context_max_tokens must be positive".to_string(),
131 ));
132 }
133 if self.limits.compact_keep_recent == 0 {
134 return Err(AgentError::Config(
135 "agent compact_keep_recent must be positive".to_string(),
136 ));
137 }
138 Ok(())
139 }
140}
Deleted lib/agent/src/runtime/engine.rs lib/agent/src/runtime/engine.rs +0 −712
@@ -1,712 +0,0 @@
1use std::sync::{Arc, Mutex};
2
3use export::{AppDatabase, AppState};
4use futures::StreamExt;
5use models::agent::artifact::AgentArtifactSource;
6use models::agent::conversation;
7use models::agent::run::{self, AgentRunState};
8use rig::agent::{
9 AgentHook, CompletionCallAction, CompletionCallEvent, HookContext, MultiTurnStreamItem,
10 PromptResponse, RequestPatch, StreamingError,
11};
12use rig::client::AgentClientExt;
13use rig::completion::message::ToolResultContent;
14use rig::completion::{Message, PromptError, Usage};
15use rig::providers::openai::CompletionsClient;
16use rig::streaming::{StreamedAssistantContent, StreamedUserContent, StreamingChat};
17use sea_orm::{ActiveModelTrait, EntityTrait, Set};
18use serde::{Deserialize, Serialize};
19use time::OffsetDateTime;
20use tokio::sync::mpsc;
21use tokio::task::JoinHandle;
22use uuid::Uuid;
23
24use super::compact::{self, Summarizer};
25use super::config::RuntimeConfig;
26use super::events::{RunEvent, StopReason};
27use super::persist::{self, RunContext, RunTerminal};
28use super::provider;
29use super::sandbox::SandboxManager;
30use super::sink::{EventEmitter, EventSink};
31use crate::error::{AgentError, Result};
32use crate::tools::artifact::save_artifact;
33use crate::tools::{ToolEnv, build_tools, truncate_output};
34
35const DEFAULT_PREAMBLE: &str = "You are GitData Agent, an autonomous engineering assistant working inside an isolated sandbox.
36Use sandbox_shell to run commands, sandbox_read_file, sandbox_write_file and sandbox_list_files to work with the sandbox filesystem, and artifact_save to persist every deliverable file you produce.
37Work step by step, verify results with the tools, and finish with a concise summary of what you did and which artifacts you saved.";
38
39const MAX_SWEEP_FILES: usize = 256;
40const MAX_SWEEP_DEPTH: usize = 8;
41
42#[derive(Clone)]
43pub struct AgentRuntime {
44 state: AppState,
45 config: RuntimeConfig,
46 client: CompletionsClient,
47}
48
49#[derive(Clone, Debug, Serialize, Deserialize)]
50pub struct RunOutcome {
51 pub run_id: Uuid,
52 pub state: AgentRunState,
53 pub stop_reason: StopReason,
54 pub final_text: Option<String>,
55 pub usage: serde_json::Value,
56 pub history: Vec<Message>,
57 pub sandbox_id: Option<String>,
58 pub artifacts: Vec<Uuid>,
59}
60
61pub struct RunHandle {
62 pub run_id: Uuid,
63 pub events: mpsc::UnboundedReceiver<RunEvent>,
64 pub outcome: JoinHandle<Result<RunOutcome>>,
65}
66
67struct Terminal {
68 state: AgentRunState,
69 stop_reason: StopReason,
70 final_text: Option<String>,
71 error: Option<String>,
72 history: Vec<Message>,
73 usage: Usage,
74}
75
76impl AgentRuntime {
77 pub fn new(state: AppState) -> Result<Self> {
78 let config = RuntimeConfig::from(&state.config.agent);
79 config.validate()?;
80 let client = provider::build_client(&config.provider)?;
81 Ok(Self {
82 state,
83 config,
84 client,
85 })
86 }
87
88 pub fn config(&self) -> &RuntimeConfig {
89 &self.config
90 }
91
92 pub async fn enqueue(&self, conversation_id: Uuid, prompt: String) -> Result<Uuid> {
93 let conv = conversation::Entity::find_by_id(conversation_id)
94 .one(self.state.database.read())
95 .await?
96 .ok_or_else(|| AgentError::NotFound(format!("agent conversation {conversation_id}")))?;
97 if conv.closed_at.is_some() {
98 return Err(AgentError::Conflict("conversation is closed".to_string()));
99 }
100 let now = OffsetDateTime::now_utc();
101 let run_id = Uuid::now_v7();
102 run::ActiveModel {
103 id: Set(run_id),
104 conversation_id: Set(conversation_id),
105 state: Set(AgentRunState::Queued),
106 prompt: Set(prompt),
107 final_text: Set(None),
108 usage: Set(serde_json::json!({})),
109 error: Set(None),
110 sandbox_id: Set(None),
111 started_at: Set(None),
112 finished_at: Set(None),
113 created_at: Set(now),
114 updated_at: Set(now),
115 }
116 .insert(self.state.database.write())
117 .await?;
118 Ok(run_id)
119 }
120
121 pub async fn submit(&self, conversation_id: Uuid, prompt: String) -> Result<RunHandle> {
122 let run_id = self.enqueue(conversation_id, prompt).await?;
123 let (tx, rx) = mpsc::unbounded_channel();
124 let rt = self.clone();
125 let outcome = tokio::spawn(async move { rt.drive(run_id, tx, true).await });
126 Ok(RunHandle {
127 run_id,
128 events: rx,
129 outcome,
130 })
131 }
132
133 pub async fn execute(&self, run_id: Uuid) -> Result<RunOutcome> {
134 let (tx, rx) = mpsc::unbounded_channel();
135 drop(rx);
136 self.clone().drive(run_id, tx, false).await
137 }
138
139 pub async fn request_cancel(&self, run_id: Uuid) -> Result<bool> {
140 persist::request_cancel(&self.state.database, run_id).await
141 }
142
143 async fn drive(
144 self,
145 run_id: Uuid,
146 events_tx: mpsc::UnboundedSender<RunEvent>,
147 consumer_cancel: bool,
148 ) -> Result<RunOutcome> {
149 let db = self.state.database.clone();
150 let sink = EventSink::new(
151 self.state.redis.clone(),
152 self.config.limits.event_stream_maxlen,
153 self.config.limits.event_ttl_secs,
154 );
155 let emitter = EventEmitter::new(sink, run_id, events_tx);
156
157 let ctx = match persist::load_run_context(&db, run_id).await {
158 Ok(ctx) => ctx,
159 Err(e) => {
160 emitter
161 .emit(RunEvent::RunError {
162 message: e.to_string(),
163 })
164 .await;
165 return Err(e);
166 }
167 };
168 match persist::mark_running(&db, run_id).await {
169 Ok(true) => {}
170 Ok(false) => {
171 let e = AgentError::Conflict(format!("run {run_id} is not queued"));
172 emitter
173 .emit(RunEvent::RunError {
174 message: e.to_string(),
175 })
176 .await;
177 return Err(e);
178 }
179 Err(e) => {
180 emitter
181 .emit(RunEvent::RunError {
182 message: e.to_string(),
183 })
184 .await;
185 return Err(e);
186 }
187 }
188 emitter
189 .emit(RunEvent::RunStarted {
190 run_id,
191 conversation_id: ctx.conversation.id,
192 agent_id: ctx.agent.id,
193 })
194 .await;
195
196 let context_max_tokens = self.config.limits.context_max_tokens;
197 let keep_recent = self.config.limits.compact_keep_recent;
198 let summarizer = Summarizer::new(self.client.clone(), self.config.provider.model.clone());
199 let prompt_message = Message::user(ctx.run.prompt.clone());
200 let mut working_history = ctx.history.clone();
201 let prompt_estimate = compact::estimate_tokens(&working_history)
202 + compact::estimate_message_tokens(&prompt_message);
203 if prompt_estimate > compact::trigger_threshold(context_max_tokens) {
204 let compaction = compact::compact_history(
205 &summarizer,
206 working_history,
207 context_max_tokens / 2,
208 keep_recent,
209 )
210 .await;
211 emit_compacted(&emitter, &compaction).await;
212 working_history = compaction.history;
213 }
214
215 let hook = RunHook {
216 db: db.clone(),
217 run_id,
218 summarizer: summarizer.clone(),
219 context_max_tokens,
220 compact_keep_recent: keep_recent,
221 emitter: emitter.clone(),
222 cache: Arc::new(Mutex::new(None)),
223 };
224
225 let manager = match SandboxManager::new(&self.config.sandbox) {
226 Ok(m) => m,
227 Err(e) => {
228 terminate_failed(&db, &emitter, &ctx, e.to_string()).await;
229 return Err(e);
230 }
231 };
232 let mut lease = match manager
233 .acquire(&db, run_id, ctx.run.sandbox_id.as_deref())
234 .await
235 {
236 Ok(lease) => lease,
237 Err(e) => {
238 terminate_failed(&db, &emitter, &ctx, format!("sandbox acquire failed: {e}")).await;
239 return Err(e);
240 }
241 };
242 manager.start_heartbeat(db.clone(), &mut lease);
243 let sandbox_id = lease.sandbox.sandbox_id.clone();
244 if let Err(e) = persist::save_sandbox_id(&db, run_id, &sandbox_id).await {
245 manager.release(&db, lease).await;
246 terminate_failed(&db, &emitter, &ctx, e.to_string()).await;
247 return Err(e);
248 }
249
250 let tool_env = Arc::new(ToolEnv {
251 sandbox: lease.sandbox.clone(),
252 state: self.state.clone(),
253 run_id,
254 emitter: emitter.clone(),
255 });
256 let preamble = ctx
257 .agent
258 .preamble
259 .as_deref()
260 .map(str::trim)
261 .filter(|p| !p.is_empty())
262 .unwrap_or(DEFAULT_PREAMBLE);
263
264 let mut usage_sum = Usage::new();
265 let mut attempt = 0;
266 let terminal = loop {
267 let agent = self
268 .client
269 .agent(self.config.provider.model.clone())
270 .preamble(preamble)
271 .dynamic_tools(build_tools(tool_env.clone()))
272 .default_max_turns(self.config.limits.default_max_turns)
273 .add_hook(hook.clone())
274 .build();
275 let mut stream = agent
276 .stream_chat(prompt_message.clone(), working_history.clone())
277 .max_turns(self.config.limits.default_max_turns)
278 .await;
279
280 let mut final_response: Option<PromptResponse> = None;
281 let mut stream_error: Option<StreamingError> = None;
282 let mut consumer_gone = false;
283 while let Some(item) = stream.next().await {
284 match item {
285 Ok(MultiTurnStreamItem::StreamAssistantItem(content)) => match content {
286 StreamedAssistantContent::Text(t) => {
287 emitter.emit(RunEvent::TextDelta { text: t.text }).await;
288 }
289 StreamedAssistantContent::ReasoningDelta { reasoning, .. } => {
290 emitter
291 .emit(RunEvent::ReasoningDelta { text: reasoning })
292 .await;
293 }
294 StreamedAssistantContent::ToolCall { tool_call, .. } => {
295 emitter
296 .emit(RunEvent::ToolCall {
297 id: tool_call.id.as_str().to_string(),
298 name: tool_call.function.name.clone(),
299 args: tool_call.function.arguments.clone(),
300 })
301 .await;
302 }
303 _ => {}
304 },
305 Ok(MultiTurnStreamItem::StreamUserItem(StreamedUserContent::ToolResult {
306 tool_result,
307 ..
308 })) => {
309 let mut output = String::new();
310 for part in &tool_result.content {
311 match part {
312 ToolResultContent::Text(t) => output.push_str(&t.text),
313 ToolResultContent::Json { value } => {
314 output.push_str(&value.to_string());
315 }
316 _ => {}
317 }
318 }
319 let (mut output, truncated) =
320 truncate_output(&output, self.config.limits.tool_output_max_bytes);
321 if truncated {
322 output.push_str("\n[truncated]");
323 }
324 emitter
325 .emit(RunEvent::ToolResult {
326 id: tool_result.call.as_str().to_string(),
327 name: tool_result.name.clone(),
328 output,
329 })
330 .await;
331 }
332 Ok(MultiTurnStreamItem::CompletionCall(call)) => {
333 usage_sum += call.usage;
334 emitter
335 .emit(RunEvent::Usage {
336 input_tokens: call.usage.input_tokens,
337 output_tokens: call.usage.output_tokens,
338 total_tokens: call.usage.total_tokens,
339 })
340 .await;
341 }
342 Ok(MultiTurnStreamItem::FinalResponse(resp)) => final_response = Some(resp),
343 Ok(_) => {}
344 Err(e) => {
345 stream_error = Some(e);
346 break;
347 }
348 }
349 if consumer_cancel && emitter.consumer_closed() {
350 consumer_gone = true;
351 break;
352 }
353 }
354 drop(stream);
355
356 if !consumer_gone
357 && attempt == 0
358 && stream_error.as_ref().is_some_and(is_context_overflow)
359 {
360 attempt += 1;
361 tracing::warn!(%run_id, "context overflow reported by provider, compacting history and retrying");
362 let compaction = compact::compact_history(
363 &summarizer,
364 working_history,
365 context_max_tokens / 4,
366 keep_recent.min(8),
367 )
368 .await;
369 emit_compacted(&emitter, &compaction).await;
370 working_history = compaction.history;
371 continue;
372 }
373
374 break if consumer_gone {
375 Terminal {
376 state: AgentRunState::Cancelled,
377 stop_reason: StopReason::Cancelled,
378 final_text: None,
379 error: Some("consumer disconnected".to_string()),
380 history: working_history,
381 usage: usage_sum,
382 }
383 } else if let Some(e) = stream_error {
384 match e {
385 StreamingError::Prompt(pe) => match *pe {
386 PromptError::MaxTurnsError {
387 max_turns,
388 chat_history,
389 ..
390 } => Terminal {
391 state: AgentRunState::Failure,
392 stop_reason: StopReason::MaxTurns,
393 final_text: None,
394 error: Some(format!("max turns exceeded ({max_turns})")),
395 history: *chat_history,
396 usage: usage_sum,
397 },
398 PromptError::PromptCancelled {
399 chat_history,
400 reason,
401 } => Terminal {
402 state: AgentRunState::Cancelled,
403 stop_reason: StopReason::Cancelled,
404 final_text: None,
405 error: Some(reason),
406 history: chat_history,
407 usage: usage_sum,
408 },
409 other => Terminal {
410 state: AgentRunState::Failure,
411 stop_reason: StopReason::Error,
412 final_text: None,
413 error: Some(other.to_string()),
414 history: working_history,
415 usage: usage_sum,
416 },
417 },
418 StreamingError::Completion(ce) => Terminal {
419 state: AgentRunState::Failure,
420 stop_reason: StopReason::Error,
421 final_text: None,
422 error: Some(ce.to_string()),
423 history: working_history,
424 usage: usage_sum,
425 },
426 }
427 } else if let Some(resp) = final_response {
428 Terminal {
429 state: AgentRunState::Success,
430 stop_reason: StopReason::Completed,
431 final_text: Some(resp.output.clone()),
432 error: None,
433 history: working_history
434 .iter()
435 .cloned()
436 .chain(resp.messages.clone().unwrap_or_default())
437 .collect(),
438 usage: resp.usage,
439 }
440 } else {
441 Terminal {
442 state: AgentRunState::Failure,
443 stop_reason: StopReason::Error,
444 final_text: None,
445 error: Some("stream ended without a final response".to_string()),
446 history: working_history,
447 usage: usage_sum,
448 }
449 };
450 };
451
452 if !self.config.limits.artifact_dir.is_empty() {
453 sweep_artifacts(&tool_env).await;
454 }
455
456 let mut out_history = terminal.history;
457 if compact::estimate_tokens(&out_history) > compact::trigger_threshold(context_max_tokens) {
458 let compaction = compact::compact_history(
459 &summarizer,
460 out_history,
461 context_max_tokens / 2,
462 keep_recent,
463 )
464 .await;
465 emit_compacted(&emitter, &compaction).await;
466 out_history = compaction.history;
467 }
468
469 let usage_json =
470 serde_json::to_value(terminal.usage).unwrap_or_else(|_| serde_json::json!({}));
471 if let Err(e) = persist::finish_run(
472 &db,
473 run_id,
474 ctx.conversation.id,
475 RunTerminal {
476 state: terminal.state,
477 final_text: terminal.final_text.clone(),
478 usage: usage_json.clone(),
479 error: terminal.error.clone(),
480 history: out_history.clone(),
481 },
482 )
483 .await
484 {
485 manager.release(&db, lease).await;
486 emitter
487 .emit(RunEvent::RunError {
488 message: e.to_string(),
489 })
490 .await;
491 return Err(e);
492 }
493 manager.release(&db, lease).await;
494
495 match terminal.stop_reason {
496 StopReason::Error => {
497 emitter
498 .emit(RunEvent::RunError {
499 message: terminal.error.clone().unwrap_or_default(),
500 })
501 .await;
502 }
503 reason => {
504 emitter
505 .emit(RunEvent::RunFinished {
506 stop_reason: reason,
507 final_text: terminal.final_text.clone(),
508 })
509 .await;
510 }
511 }
512
513 let artifacts = persist::artifact_ids(&db, run_id).await.unwrap_or_default();
514 Ok(RunOutcome {
515 run_id,
516 state: terminal.state,
517 stop_reason: terminal.stop_reason,
518 final_text: terminal.final_text,
519 usage: usage_json,
520 history: out_history,
521 sandbox_id: Some(sandbox_id),
522 artifacts,
523 })
524 }
525}
526
527#[derive(Clone)]
528struct RunHook {
529 db: Arc<AppDatabase>,
530 run_id: Uuid,
531 summarizer: Summarizer,
532 context_max_tokens: usize,
533 compact_keep_recent: usize,
534 emitter: EventEmitter,
535 cache: Arc<Mutex<Option<CompactCache>>>,
536}
537
538#[derive(Clone)]
539struct CompactCache {
540 prefix_len: usize,
541 summary: String,
542}
543
544impl RunHook {
545 fn cached_patch(&self, history: &[Message], threshold: usize) -> Option<Vec<Message>> {
546 let cache = self.cache.lock().ok()?.clone()?;
547 if cache.prefix_len >= history.len() {
548 return None;
549 }
550 let tail = &history[cache.prefix_len..];
551 if tail.is_empty() || compact::starts_with_tool_result(&tail[0]) {
552 return None;
553 }
554 let summary = compact::summary_message(&cache.summary);
555 let estimate = compact::estimate_message_tokens(&summary) + compact::estimate_tokens(tail);
556 if estimate > threshold {
557 return None;
558 }
559 let mut patched = Vec::with_capacity(tail.len() + 1);
560 patched.push(summary);
561 patched.extend_from_slice(tail);
562 Some(patched)
563 }
564}
565
566impl AgentHook for RunHook {
567 async fn on_completion_call(
568 &self,
569 _ctx: &HookContext,
570 event: CompletionCallEvent<'_>,
571 ) -> CompletionCallAction {
572 match persist::cancel_requested(&self.db, self.run_id).await {
573 Ok(true) => return CompletionCallAction::stop("cancel requested"),
574 Ok(false) => {}
575 Err(e) => {
576 tracing::warn!(error = %e, "agent run cancel check failed");
577 }
578 }
579
580 let threshold = compact::trigger_threshold(self.context_max_tokens);
581 let history = event.history;
582 if compact::estimate_tokens(history) <= threshold {
583 return CompletionCallAction::continue_run();
584 }
585 if let Some(patched) = self.cached_patch(history, threshold) {
586 return CompletionCallAction::patch(RequestPatch::new().history(patched));
587 }
588
589 let compaction = compact::compact_history(
590 &self.summarizer,
591 history.to_vec(),
592 self.context_max_tokens / 2,
593 self.compact_keep_recent,
594 )
595 .await;
596 if let (Some(summary), Ok(mut cache)) = (&compaction.summary, self.cache.lock()) {
597 cache.replace(CompactCache {
598 prefix_len: compaction.prefix_len,
599 summary: summary.clone(),
600 });
601 }
602 emit_compacted(&self.emitter, &compaction).await;
603 CompletionCallAction::patch(RequestPatch::new().history(compaction.history))
604 }
605}
606
607fn is_context_overflow(error: &StreamingError) -> bool {
608 let completion_error = match error {
609 StreamingError::Completion(ce) => Some(ce),
610 StreamingError::Prompt(pe) => match pe.as_ref() {
611 PromptError::CompletionError(ce) => Some(ce),
612 _ => None,
613 },
614 };
615 let Some(ce) = completion_error else {
616 return false;
617 };
618 let body = ce
619 .provider_response_body()
620 .unwrap_or_default()
621 .to_lowercase();
622 body.contains("context_length_exceeded")
623 || body.contains("maximum context length")
624 || body.contains("input is too long")
625}
626
627async fn emit_compacted(emitter: &EventEmitter, compaction: &compact::Compaction) {
628 emitter
629 .emit(RunEvent::HistoryCompacted {
630 before: compaction.before,
631 after: compaction.after,
632 estimated_tokens: compaction.estimated_tokens,
633 method: compaction.method,
634 })
635 .await;
636}
637
638async fn terminate_failed(
639 db: &Arc<AppDatabase>,
640 emitter: &EventEmitter,
641 ctx: &RunContext,
642 message: String,
643) {
644 let terminal = RunTerminal {
645 state: AgentRunState::Failure,
646 final_text: None,
647 usage: serde_json::json!({}),
648 error: Some(message.clone()),
649 history: ctx.history.clone(),
650 };
651 if let Err(e) = persist::finish_run(db, ctx.run.id, ctx.conversation.id, terminal).await {
652 tracing::error!(run_id = %ctx.run.id, error = %e, "failed to persist agent run failure");
653 }
654 emitter.emit(RunEvent::RunError { message }).await;
655}
656
657async fn sweep_artifacts(env: &Arc<ToolEnv>) {
658 let dir = env.limits().artifact_dir.clone();
659 if dir.is_empty() {
660 return;
661 }
662 let existing = match persist::artifact_paths(env.db(), env.run_id).await {
663 Ok(paths) => paths,
664 Err(e) => {
665 tracing::warn!(error = %e, "failed to load existing artifact paths");
666 return;
667 }
668 };
669 let files = env.sandbox.files();
670 let mut stack: Vec<(String, usize)> = vec![(dir, 0)];
671 let mut budget = MAX_SWEEP_FILES;
672 while let Some((path, depth)) = stack.pop() {
673 if depth > MAX_SWEEP_DEPTH {
674 continue;
675 }
676 let entries = match files.list(&path).await {
677 Ok(entries) => entries,
678 Err(e) => {
679 tracing::warn!(path = %path, error = %e, "artifact sweep list failed");
680 continue;
681 }
682 };
683 for entry in entries {
684 if entry.is_dir() {
685 stack.push((entry.path, depth + 1));
686 continue;
687 }
688 if budget == 0 {
689 return;
690 }
691 if existing.contains(&entry.path) {
692 continue;
693 }
694 match save_artifact(env, &entry.path, None, AgentArtifactSource::Sweep).await {
695 Ok(row) => {
696 env.emitter
697 .emit(RunEvent::ArtifactSaved {
698 artifact_id: row.id,
699 name: row.name.clone(),
700 sandbox_path: row.sandbox_path.clone(),
701 size: row.size,
702 })
703 .await;
704 budget -= 1;
705 }
706 Err(message) => {
707 tracing::warn!(path = %entry.path, error = %message, "artifact sweep save failed");
708 }
709 }
710 }
711 }
712}
Deleted lib/agent/src/runtime/events.rs lib/agent/src/runtime/events.rs +0 −68
@@ -1,68 +0,0 @@
1use serde::{Deserialize, Serialize};
2use uuid::Uuid;
3
4#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
5#[serde(rename_all = "snake_case")]
6pub enum StopReason {
7 Completed,
8 MaxTurns,
9 Cancelled,
10 Error,
11}
12
13#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
14#[serde(rename_all = "snake_case")]
15pub enum CompactMethod {
16 Summary,
17 Truncate,
18}
19
20#[derive(Clone, Debug, Serialize, Deserialize)]
21#[serde(tag = "type", rename_all = "snake_case")]
22pub enum RunEvent {
23 RunStarted {
24 run_id: Uuid,
25 conversation_id: Uuid,
26 agent_id: Uuid,
27 },
28 TextDelta {
29 text: String,
30 },
31 ReasoningDelta {
32 text: String,
33 },
34 ToolCall {
35 id: String,
36 name: String,
37 args: serde_json::Value,
38 },
39 ToolResult {
40 id: String,
41 name: String,
42 output: String,
43 },
44 ArtifactSaved {
45 artifact_id: Uuid,
46 name: String,
47 sandbox_path: String,
48 size: i64,
49 },
50 Usage {
51 input_tokens: u64,
52 output_tokens: u64,
53 total_tokens: u64,
54 },
55 HistoryCompacted {
56 before: usize,
57 after: usize,
58 estimated_tokens: usize,
59 method: CompactMethod,
60 },
61 RunFinished {
62 stop_reason: StopReason,
63 final_text: Option<String>,
64 },
65 RunError {
66 message: String,
67 },
68}
Deleted lib/agent/src/runtime/mod.rs lib/agent/src/runtime/mod.rs +0 −18
@@ -1,18 +0,0 @@
1pub mod compact;
2pub mod config;
3pub mod engine;
4pub mod events;
5pub mod persist;
6pub mod provider;
7pub mod reaper;
8pub mod sandbox;
9pub mod sink;
10pub mod task;
11
12pub use compact::{Compaction, Summarizer};
13pub use config::RuntimeConfig;
14pub use engine::{AgentRuntime, RunHandle, RunOutcome};
15pub use events::{CompactMethod, RunEvent, StopReason};
16pub use reaper::{SweepReport, sweep};
17pub use sink::{EventEmitter, EventSink, StreamEntry};
18pub use task::RunTask;
Deleted lib/agent/src/runtime/persist.rs lib/agent/src/runtime/persist.rs +0 −238
@@ -1,238 +0,0 @@
1use export::AppDatabase;
2use models::agent::artifact::{self, AgentArtifactSource};
3use models::agent::run::{self, AgentRunState};
4use models::agent::sandbox::{self, AgentSandboxState};
5use models::agent::{agent, conversation};
6use rig::completion::Message;
7use sea_orm::sea_query::Expr;
8use sea_orm::{ActiveModelTrait, ColumnTrait, EntityTrait, QueryFilter, QueryOrder, Set};
9use time::OffsetDateTime;
10use uuid::Uuid;
11
12use crate::error::{AgentError, Result};
13
14pub struct RunContext {
15 pub run: run::Model,
16 pub conversation: conversation::Model,
17 pub agent: agent::Model,
18 pub history: Vec<Message>,
19}
20
21pub async fn load_run_context(db: &AppDatabase, run_id: Uuid) -> Result<RunContext> {
22 let run = run::Entity::find_by_id(run_id)
23 .one(db.read())
24 .await?
25 .ok_or_else(|| AgentError::NotFound(format!("agent run {run_id}")))?;
26 let conversation = conversation::Entity::find_by_id(run.conversation_id)
27 .one(db.read())
28 .await?
29 .ok_or_else(|| {
30 AgentError::NotFound(format!("agent conversation {}", run.conversation_id))
31 })?;
32 let agent = agent::Entity::find_by_id(conversation.agent_id)
33 .one(db.read())
34 .await?
35 .ok_or_else(|| AgentError::NotFound(format!("agent {}", conversation.agent_id)))?;
36 let history: Vec<Message> = serde_json::from_value(conversation.history.clone())
37 .map_err(|e| AgentError::Internal(format!("corrupt conversation history: {e}")))?;
38 Ok(RunContext {
39 run,
40 conversation,
41 agent,
42 history,
43 })
44}
45
46pub async fn mark_running(db: &AppDatabase, run_id: Uuid) -> Result<bool> {
47 let now = OffsetDateTime::now_utc();
48 let res = run::Entity::update_many()
49 .col_expr(run::Column::State, Expr::value(AgentRunState::Running))
50 .col_expr(run::Column::StartedAt, Expr::value(Some(now)))
51 .col_expr(run::Column::UpdatedAt, Expr::value(now))
52 .filter(run::Column::Id.eq(run_id))
53 .filter(run::Column::State.eq(AgentRunState::Queued))
54 .exec(db.write())
55 .await?;
56 Ok(res.rows_affected == 1)
57}
58
59pub async fn request_cancel(db: &AppDatabase, run_id: Uuid) -> Result<bool> {
60 let now = OffsetDateTime::now_utc();
61 let res = run::Entity::update_many()
62 .col_expr(
63 run::Column::State,
64 Expr::value(AgentRunState::CancelRequested),
65 )
66 .col_expr(run::Column::UpdatedAt, Expr::value(now))
67 .filter(run::Column::Id.eq(run_id))
68 .filter(run::Column::State.eq(AgentRunState::Running))
69 .exec(db.write())
70 .await?;
71 Ok(res.rows_affected == 1)
72}
73
74pub async fn cancel_requested(db: &AppDatabase, run_id: Uuid) -> Result<bool> {
75 let row = run::Entity::find_by_id(run_id).one(db.write()).await?;
76 Ok(matches!(
77 row.map(|r| r.state),
78 Some(AgentRunState::CancelRequested)
79 ))
80}
81
82pub async fn save_sandbox_id(db: &AppDatabase, run_id: Uuid, sandbox_id: &str) -> Result<()> {
83 run::Entity::update_many()
84 .col_expr(run::Column::SandboxId, Expr::value(sandbox_id.to_string()))
85 .col_expr(
86 run::Column::UpdatedAt,
87 Expr::value(OffsetDateTime::now_utc()),
88 )
89 .filter(run::Column::Id.eq(run_id))
90 .exec(db.write())
91 .await?;
92 Ok(())
93}
94
95pub struct RunTerminal {
96 pub state: AgentRunState,
97 pub final_text: Option<String>,
98 pub usage: serde_json::Value,
99 pub error: Option<String>,
100 pub history: Vec<Message>,
101}
102
103pub async fn finish_run(
104 db: &AppDatabase,
105 run_id: Uuid,
106 conversation_id: Uuid,
107 terminal: RunTerminal,
108) -> Result<()> {
109 let now = OffsetDateTime::now_utc();
110 run::Entity::update_many()
111 .col_expr(run::Column::State, Expr::value(terminal.state))
112 .col_expr(run::Column::FinalText, Expr::value(terminal.final_text))
113 .col_expr(run::Column::Usage, Expr::value(terminal.usage))
114 .col_expr(run::Column::Error, Expr::value(terminal.error))
115 .col_expr(run::Column::FinishedAt, Expr::value(Some(now)))
116 .col_expr(run::Column::UpdatedAt, Expr::value(now))
117 .filter(run::Column::Id.eq(run_id))
118 .exec(db.write())
119 .await?;
120 let history = serde_json::to_value(&terminal.history)
121 .map_err(|e| AgentError::Internal(format!("serialize conversation history: {e}")))?;
122 conversation::Entity::update_many()
123 .col_expr(conversation::Column::History, Expr::value(history))
124 .col_expr(conversation::Column::LastRunAt, Expr::value(Some(now)))
125 .col_expr(conversation::Column::UpdatedAt, Expr::value(Some(now)))
126 .filter(conversation::Column::Id.eq(conversation_id))
127 .exec(db.write())
128 .await?;
129 Ok(())
130}
131
132pub async fn insert_sandbox(
133 db: &AppDatabase,
134 run_id: Uuid,
135 sandbox_id: &str,
136 template_id: &str,
137 lease_expires_at: OffsetDateTime,
138) -> Result<Uuid> {
139 let now = OffsetDateTime::now_utc();
140 let id = Uuid::now_v7();
141 sandbox::ActiveModel {
142 id: Set(id),
143 run_id: Set(run_id),
144 sandbox_id: Set(sandbox_id.to_string()),
145 template_id: Set(template_id.to_string()),
146 state: Set(AgentSandboxState::Active),
147 lease_expires_at: Set(lease_expires_at),
148 last_heartbeat_at: Set(Some(now)),
149 created_at: Set(now),
150 killed_at: Set(None),
151 }
152 .insert(db.write())
153 .await?;
154 Ok(id)
155}
156
157pub async fn heartbeat(
158 db: &AppDatabase,
159 row_id: Uuid,
160 lease_expires_at: OffsetDateTime,
161) -> Result<()> {
162 sandbox::Entity::update_many()
163 .col_expr(
164 sandbox::Column::LastHeartbeatAt,
165 Expr::value(Some(OffsetDateTime::now_utc())),
166 )
167 .col_expr(
168 sandbox::Column::LeaseExpiresAt,
169 Expr::value(lease_expires_at),
170 )
171 .filter(sandbox::Column::Id.eq(row_id))
172 .filter(sandbox::Column::State.eq(AgentSandboxState::Active))
173 .exec(db.write())
174 .await?;
175 Ok(())
176}
177
178pub async fn set_sandbox_state(
179 db: &AppDatabase,
180 row_id: Uuid,
181 state: AgentSandboxState,
182 killed_at: Option<OffsetDateTime>,
183) -> Result<()> {
184 let mut stmt = sandbox::Entity::update_many()
185 .col_expr(sandbox::Column::State, Expr::value(state))
186 .filter(sandbox::Column::Id.eq(row_id));
187 if let Some(at) = killed_at {
188 stmt = stmt.col_expr(sandbox::Column::KilledAt, Expr::value(Some(at)));
189 }
190 stmt.exec(db.write()).await?;
191 Ok(())
192}
193
194#[allow(clippy::too_many_arguments)]
195pub async fn insert_artifact(
196 db: &AppDatabase,
197 run_id: Uuid,
198 name: &str,
199 sandbox_path: &str,
200 bucket: &str,
201 s3_key: &str,
202 size: i64,
203 content_type: &str,
204 source: AgentArtifactSource,
205) -> Result<artifact::Model> {
206 let row = artifact::ActiveModel {
207 id: Set(Uuid::now_v7()),
208 run_id: Set(run_id),
209 name: Set(name.to_string()),
210 sandbox_path: Set(sandbox_path.to_string()),
211 bucket: Set(bucket.to_string()),
212 s3_key: Set(s3_key.to_string()),
213 size: Set(size),
214 content_type: Set(content_type.to_string()),
215 source: Set(source),
216 created_at: Set(OffsetDateTime::now_utc()),
217 }
218 .insert(db.write())
219 .await?;
220 Ok(row)
221}
222
223pub async fn artifact_ids(db: &AppDatabase, run_id: Uuid) -> Result<Vec<Uuid>> {
224 let rows = artifact::Entity::find()
225 .filter(artifact::Column::RunId.eq(run_id))
226 .order_by_asc(artifact::Column::CreatedAt)
227 .all(db.read())
228 .await?;
229 Ok(rows.into_iter().map(|r| r.id).collect())
230}
231
232pub async fn artifact_paths(db: &AppDatabase, run_id: Uuid) -> Result<Vec<String>> {
233 let rows = artifact::Entity::find()
234 .filter(artifact::Column::RunId.eq(run_id))
235 .all(db.read())
236 .await?;
237 Ok(rows.into_iter().map(|r| r.sandbox_path).collect())
238}
Deleted lib/agent/src/runtime/provider.rs lib/agent/src/runtime/provider.rs +0 −12
@@ -1,12 +0,0 @@
1use rig::providers::openai::CompletionsClient;
2
3use super::config::ProviderSettings;
4use crate::error::{AgentError, Result};
5
6pub fn build_client(settings: &ProviderSettings) -> Result<CompletionsClient> {
7 CompletionsClient::builder()
8 .api_key(settings.api_key.clone())
9 .base_url(settings.base_url.as_str())
10 .build()
11 .map_err(|e| AgentError::Provider(e.to_string()))
12}
Deleted lib/agent/src/runtime/reaper.rs lib/agent/src/runtime/reaper.rs +0 −168
@@ -1,168 +0,0 @@
1use std::collections::HashSet;
2
3use export::AppState;
4use models::agent::run::{self, AgentRunState};
5use models::agent::sandbox::{self, AgentSandboxState};
6use sea_orm::sea_query::Expr;
7use sea_orm::{ColumnTrait, EntityTrait, QueryFilter, QueryOrder};
8use time::OffsetDateTime;
9
10use super::config::RuntimeConfig;
11use super::events::RunEvent;
12use super::sandbox::{MANAGED_BY_KEY, MANAGED_BY_VALUE, SandboxManager};
13use super::sink::EventSink;
14use crate::error::Result;
15
16#[derive(Debug, Default)]
17pub struct SweepReport {
18 pub killed: usize,
19 pub lost: usize,
20 pub orphaned: usize,
21 pub failed_runs: usize,
22}
23
24pub async fn sweep(state: &AppState, config: &RuntimeConfig) -> Result<SweepReport> {
25 let mut report = SweepReport::default();
26 let db = &state.database;
27 let manager = SandboxManager::new(&config.sandbox)?;
28 let cutoff =
29 OffsetDateTime::now_utc() - time::Duration::seconds(config.sandbox.lease.as_secs() as i64);
30
31 let expired = sandbox::Entity::find()
32 .filter(sandbox::Column::State.is_in([
33 AgentSandboxState::Creating,
34 AgentSandboxState::Active,
35 AgentSandboxState::Killing,
36 ]))
37 .filter(sandbox::Column::LeaseExpiresAt.lt(cutoff))
38 .all(db.read())
39 .await?;
40 for row in expired {
41 match manager.client().connect(&row.sandbox_id).await {
42 Ok(sb) => match sb.kill().await {
43 Ok(()) => {
44 report.killed += 1;
45 mark_sandbox(db, row.id, AgentSandboxState::Killed).await;
46 }
47 Err(e) if e.is_sandbox_not_found() => {
48 report.killed += 1;
49 mark_sandbox(db, row.id, AgentSandboxState::Killed).await;
50 }
51 Err(e) => {
52 tracing::warn!(sandbox_id = %row.sandbox_id, error = %e, "reaper kill failed, will retry");
53 }
54 },
55 Err(e) if e.is_sandbox_not_found() => {
56 report.lost += 1;
57 mark_sandbox(db, row.id, AgentSandboxState::Lost).await;
58 }
59 Err(e) => {
60 tracing::warn!(sandbox_id = %row.sandbox_id, error = %e, "reaper connect failed, will retry");
61 }
62 }
63 }
64
65 let tracked: HashSet<String> = sandbox::Entity::find()
66 .filter(sandbox::Column::State.is_in([
67 AgentSandboxState::Creating,
68 AgentSandboxState::Active,
69 AgentSandboxState::Killing,
70 ]))
71 .all(db.read())
72 .await?
73 .into_iter()
74 .map(|r| r.sandbox_id)
75 .collect();
76 match manager.client().list().await {
77 Ok(infos) => {
78 for info in infos {
79 if info.template_id != config.sandbox.template_id
80 || tracked.contains(&info.sandbox_id)
81 || info.metadata.get(MANAGED_BY_KEY).map(String::as_str)
82 != Some(MANAGED_BY_VALUE)
83 {
84 continue;
85 }
86 match manager.client().connect(&info.sandbox_id).await {
87 Ok(sb) => match sb.kill().await {
88 Ok(()) => report.orphaned += 1,
89 Err(e) if e.is_sandbox_not_found() => {}
90 Err(e) => {
91 tracing::warn!(sandbox_id = %info.sandbox_id, error = %e, "reaper orphan kill failed");
92 }
93 },
94 Err(e) => {
95 tracing::warn!(sandbox_id = %info.sandbox_id, error = %e, "reaper orphan connect failed");
96 }
97 }
98 }
99 }
100 Err(e) => {
101 tracing::warn!(error = %e, "cube sandbox listing failed, skipping reconciliation");
102 }
103 }
104
105 let sink = EventSink::new(
106 state.redis.clone(),
107 config.limits.event_stream_maxlen,
108 config.limits.event_ttl_secs,
109 );
110 let running = run::Entity::find()
111 .filter(run::Column::State.eq(AgentRunState::Running))
112 .all(db.read())
113 .await?;
114 for r in running {
115 let stranded_long_ago =
116 r.started_at.is_some_and(|started| started < cutoff) || r.started_at.is_none();
117 if !stranded_long_ago {
118 continue;
119 }
120 let sb = sandbox::Entity::find()
121 .filter(sandbox::Column::RunId.eq(r.id))
122 .order_by_desc(sandbox::Column::CreatedAt)
123 .one(db.read())
124 .await?;
125 let stranded = match &sb {
126 None => true,
127 Some(s) => matches!(s.state, AgentSandboxState::Killed | AgentSandboxState::Lost),
128 };
129 if !stranded {
130 continue;
131 }
132 let now = OffsetDateTime::now_utc();
133 run::Entity::update_many()
134 .col_expr(run::Column::State, Expr::value(AgentRunState::Failure))
135 .col_expr(
136 run::Column::Error,
137 Expr::value(Some("sandbox lost".to_string())),
138 )
139 .col_expr(run::Column::FinishedAt, Expr::value(Some(now)))
140 .col_expr(run::Column::UpdatedAt, Expr::value(now))
141 .filter(run::Column::Id.eq(r.id))
142 .filter(run::Column::State.eq(AgentRunState::Running))
143 .exec(db.write())
144 .await?;
145 if let Err(e) = sink
146 .append(
147 r.id,
148 &RunEvent::RunError {
149 message: "sandbox lost".to_string(),
150 },
151 )
152 .await
153 {
154 tracing::warn!(run_id = %r.id, error = %e, "failed to record sandbox-lost event");
155 }
156 report.failed_runs += 1;
157 }
158
159 Ok(report)
160}
161
162async fn mark_sandbox(db: &export::AppDatabase, row_id: uuid::Uuid, state: AgentSandboxState) {
163 if let Err(e) =
164 super::persist::set_sandbox_state(db, row_id, state, Some(OffsetDateTime::now_utc())).await
165 {
166 tracing::warn!(error = %e, "failed to update agent sandbox state");
167 }
168}
Deleted lib/agent/src/runtime/sandbox.rs lib/agent/src/runtime/sandbox.rs +0 −154
@@ -1,154 +0,0 @@
1use std::sync::Arc;
2use std::time::Duration;
3
4use cubesandbox::{Client, Config, CreateOptions, Sandbox, Timeout};
5use export::AppDatabase;
6use models::agent::sandbox::AgentSandboxState;
7use time::OffsetDateTime;
8use tokio::task::JoinHandle;
9use uuid::Uuid;
10
11use super::config::SandboxSettings;
12use super::persist;
13use crate::error::Result;
14
15pub const MANAGED_BY_KEY: &str = "managed_by";
16pub const MANAGED_BY_VALUE: &str = "gitdata-agent";
17
18#[derive(Clone)]
19pub struct SandboxManager {
20 client: Client,
21 settings: SandboxSettings,
22}
23
24pub struct Lease {
25 pub sandbox: Sandbox,
26 pub row_id: Uuid,
27 heartbeat: Option<JoinHandle<()>>,
28}
29
30fn deadline_after(lease: Duration) -> OffsetDateTime {
31 OffsetDateTime::now_utc() + time::Duration::seconds(lease.as_secs() as i64)
32}
33
34impl SandboxManager {
35 pub fn new(settings: &SandboxSettings) -> Result<Self> {
36 let config = Config {
37 api_url: settings.api_url.clone(),
38 api_key: settings.api_key.clone(),
39 template_id: settings.template_id.clone(),
40 timeout: Timeout::After(settings.lease),
41 ..Default::default()
42 };
43 let client = Client::new(config)?;
44 Ok(Self {
45 client,
46 settings: settings.clone(),
47 })
48 }
49
50 pub fn client(&self) -> &Client {
51 &self.client
52 }
53
54 pub async fn acquire(
55 &self,
56 db: &AppDatabase,
57 run_id: Uuid,
58 existing: Option<&str>,
59 ) -> Result<Lease> {
60 if let Some(sandbox_id) = existing {
61 match self.client.connect(sandbox_id).await {
62 Ok(sandbox) => return self.register(db, run_id, &sandbox).await,
63 Err(e) => {
64 tracing::warn!(sandbox_id, error = %e, "adopting sandbox failed, creating a new one");
65 }
66 }
67 }
68 let sandbox = self
69 .client
70 .create(
71 CreateOptions::new()
72 .template(self.settings.template_id.clone())
73 .timeout(Timeout::After(self.settings.lease))
74 .metadata(MANAGED_BY_KEY, MANAGED_BY_VALUE),
75 )
76 .await?;
77 self.register(db, run_id, &sandbox).await
78 }
79
80 async fn register(&self, db: &AppDatabase, run_id: Uuid, sandbox: &Sandbox) -> Result<Lease> {
81 let row_id = persist::insert_sandbox(
82 db,
83 run_id,
84 &sandbox.sandbox_id,
85 &self.settings.template_id,
86 deadline_after(self.settings.lease),
87 )
88 .await?;
89 Ok(Lease {
90 sandbox: sandbox.clone(),
91 row_id,
92 heartbeat: None,
93 })
94 }
95
96 pub fn start_heartbeat(&self, db: Arc<AppDatabase>, lease: &mut Lease) {
97 let sandbox = lease.sandbox.clone();
98 let row_id = lease.row_id;
99 let every = (self.settings.lease / 3).max(Duration::from_secs(1));
100 let lease_dur = self.settings.lease;
101 lease.heartbeat = Some(tokio::spawn(async move {
102 let mut ticker = tokio::time::interval(every);
103 ticker.tick().await;
104 loop {
105 ticker.tick().await;
106 if let Err(e) = persist::heartbeat(&db, row_id, deadline_after(lease_dur)).await {
107 tracing::warn!(error = %e, "agent sandbox heartbeat persist failed");
108 }
109 if let Err(e) = sandbox.set_timeout(Timeout::After(lease_dur)).await {
110 tracing::warn!(error = %e, "agent sandbox timeout renew failed");
111 }
112 }
113 }));
114 }
115
116 pub async fn release(&self, db: &AppDatabase, lease: Lease) {
117 if let Some(handle) = lease.heartbeat {
118 handle.abort();
119 }
120 let now = OffsetDateTime::now_utc();
121 if let Err(e) =
122 persist::set_sandbox_state(db, lease.row_id, AgentSandboxState::Killing, None).await
123 {
124 tracing::warn!(error = %e, "failed to mark agent sandbox killing");
125 }
126 match lease.sandbox.kill().await {
127 Ok(()) => {
128 let _ = persist::set_sandbox_state(
129 db,
130 lease.row_id,
131 AgentSandboxState::Killed,
132 Some(now),
133 )
134 .await;
135 }
136 Err(e) if e.is_sandbox_not_found() => {
137 let _ = persist::set_sandbox_state(
138 db,
139 lease.row_id,
140 AgentSandboxState::Killed,
141 Some(now),
142 )
143 .await;
144 }
145 Err(e) => {
146 tracing::error!(
147 sandbox_id = %lease.sandbox.sandbox_id,
148 error = %e,
149 "agent sandbox kill failed, reaper will retry"
150 );
151 }
152 }
153 }
154}
Deleted lib/agent/src/runtime/sink.rs lib/agent/src/runtime/sink.rs +0 −143
@@ -1,143 +0,0 @@
1use export::{AppRedis, RedisConnection};
2use tokio::sync::mpsc;
3use uuid::Uuid;
4
5use super::events::RunEvent;
6use crate::error::{AgentError, Result};
7
8macro_rules! dispatch {
9 ($conn:expr, |$c:ident| $body:expr) => {
10 match &mut $conn {
11 RedisConnection::Standalone($c) => $body,
12 RedisConnection::Cluster($c) => $body,
13 }
14 };
15}
16
17pub fn stream_key(run_id: Uuid) -> String {
18 format!("agent:run:{run_id}:events")
19}
20
21#[derive(Clone, Debug)]
22pub struct StreamEntry {
23 pub id: String,
24 pub event: RunEvent,
25}
26
27#[derive(Clone)]
28pub struct EventSink {
29 redis: AppRedis,
30 maxlen: u64,
31 ttl_secs: u64,
32}
33
34impl EventSink {
35 pub fn new(redis: AppRedis, maxlen: u64, ttl_secs: u64) -> Self {
36 Self {
37 redis,
38 maxlen: maxlen.max(1),
39 ttl_secs,
40 }
41 }
42
43 pub async fn append(&self, run_id: Uuid, event: &RunEvent) -> Result<()> {
44 let payload = serde_json::to_string(event)
45 .map_err(|e| AgentError::Internal(format!("serialize run event: {e}")))?;
46 let key = stream_key(run_id);
47 let mut conn = self.redis.connection_clone();
48 let _: redis::Value = dispatch!(conn, |c| {
49 redis::cmd("XADD")
50 .arg(&key)
51 .arg("MAXLEN")
52 .arg("~")
53 .arg(self.maxlen)
54 .arg("*")
55 .arg("event")
56 .arg(&payload)
57 .query_async(c)
58 .await
59 })?;
60 if self.ttl_secs > 0 {
61 let _: redis::Value = dispatch!(conn, |c| {
62 redis::cmd("EXPIRE")
63 .arg(&key)
64 .arg(self.ttl_secs)
65 .query_async(c)
66 .await
67 })?;
68 }
69 Ok(())
70 }
71
72 pub async fn read_events(&self, run_id: Uuid, start: &str) -> Result<Vec<StreamEntry>> {
73 let key = stream_key(run_id);
74 let mut conn = self.redis.connection_clone();
75 let value: redis::Value = dispatch!(conn, |c| {
76 redis::cmd("XRANGE")
77 .arg(&key)
78 .arg(start)
79 .arg("+")
80 .query_async(c)
81 .await
82 })?;
83 Ok(parse_stream_entries(value))
84 }
85}
86
87fn parse_stream_entries(value: redis::Value) -> Vec<StreamEntry> {
88 let redis::Value::Array(entries) = value else {
89 return Vec::new();
90 };
91 let mut out = Vec::with_capacity(entries.len());
92 for entry in entries {
93 let redis::Value::Array(mut fields) = entry else {
94 continue;
95 };
96 if fields.len() != 2 {
97 continue;
98 }
99 let body = fields.pop().expect("len checked");
100 let id = fields.pop().expect("len checked");
101 let (redis::Value::BulkString(id), redis::Value::Array(pairs)) = (id, body) else {
102 continue;
103 };
104 if pairs.len() != 2 {
105 continue;
106 }
107 let redis::Value::BulkString(payload) = &pairs[1] else {
108 continue;
109 };
110 match serde_json::from_slice::<RunEvent>(payload) {
111 Ok(event) => out.push(StreamEntry {
112 id: String::from_utf8_lossy(&id).into_owned(),
113 event,
114 }),
115 Err(e) => tracing::warn!(error = %e, "skipping malformed agent run event"),
116 }
117 }
118 out
119}
120
121#[derive(Clone)]
122pub struct EventEmitter {
123 sink: EventSink,
124 run_id: Uuid,
125 tx: mpsc::UnboundedSender<RunEvent>,
126}
127
128impl EventEmitter {
129 pub fn new(sink: EventSink, run_id: Uuid, tx: mpsc::UnboundedSender<RunEvent>) -> Self {
130 Self { sink, run_id, tx }
131 }
132
133 pub async fn emit(&self, event: RunEvent) {
134 if let Err(e) = self.sink.append(self.run_id, &event).await {
135 tracing::warn!(run_id = %self.run_id, error = %e, "failed to append agent run event");
136 }
137 let _ = self.tx.send(event);
138 }
139
140 pub fn consumer_closed(&self) -> bool {
141 self.tx.is_closed()
142 }
143}
Deleted lib/agent/src/runtime/task.rs lib/agent/src/runtime/task.rs +0 −13
@@ -1,13 +0,0 @@
1use serde::{Deserialize, Serialize};
2use uuid::Uuid;
3
4#[derive(Clone, Debug, Serialize, Deserialize)]
5pub struct RunTask {
6 pub run_id: Uuid,
7}
8
9impl RunTask {
10 pub fn new(run_id: Uuid) -> Self {
11 Self { run_id }
12 }
13}
Deleted lib/agent/src/tools/artifact.rs lib/agent/src/tools/artifact.rs +0 −163
@@ -1,163 +0,0 @@
1use std::sync::Arc;
2
3use models::agent::artifact::{AgentArtifactSource, Model as ArtifactModel};
4use rig::tool::{DynamicTool, ToolExecutionError, ToolOutput};
5use serde::Deserialize;
6use serde_json::json;
7use uuid::Uuid;
8
9use super::ToolEnv;
10use crate::runtime::events::RunEvent;
11use crate::runtime::persist;
12
13pub fn artifact_tool(env: Arc<ToolEnv>) -> DynamicTool {
14 DynamicTool::new(
15 "artifact_save",
16 "Save a file from the sandbox as a run artifact. The file is uploaded to persistent object storage and survives sandbox shutdown. Call this for every deliverable the task produced.",
17 json!({
18 "type": "object",
19 "properties": {
20 "path": {
21 "type": "string",
22 "description": "Absolute path of the file inside the sandbox"
23 },
24 "name": {
25 "type": "string",
26 "description": "Optional display name; defaults to the file name"
27 }
28 },
29 "required": ["path"]
30 }),
31 move |_ctx, args| {
32 let env = env.clone();
33 Box::pin(async move {
34 #[derive(Deserialize)]
35 struct Args {
36 path: String,
37 name: Option<String>,
38 }
39 let a: Args = serde_json::from_value(args)
40 .map_err(|e| ToolExecutionError::invalid_args(e.to_string()))?;
41 match save_artifact(&env, &a.path, a.name.as_deref(), AgentArtifactSource::Tool)
42 .await
43 {
44 Ok(row) => {
45 env.emitter
46 .emit(RunEvent::ArtifactSaved {
47 artifact_id: row.id,
48 name: row.name.clone(),
49 sandbox_path: row.sandbox_path.clone(),
50 size: row.size,
51 })
52 .await;
53 Ok(ToolOutput::json(json!({
54 "artifact_id": row.id.to_string(),
55 "name": row.name,
56 "size": row.size,
57 })))
58 }
59 Err(message) => Err(ToolExecutionError::other(message)),
60 }
61 })
62 },
63 )
64}
65
66pub async fn save_artifact(
67 env: &ToolEnv,
68 path: &str,
69 name: Option<&str>,
70 source: AgentArtifactSource,
71) -> std::result::Result<ArtifactModel, String> {
72 let bytes = env
73 .sandbox
74 .files()
75 .read_bytes(path)
76 .await
77 .map_err(|e| e.to_string())?;
78 if bytes.is_empty() {
79 return Err(format!("{path} is empty"));
80 }
81 let max = env.limits().artifact_max_size as usize;
82 if bytes.len() > max {
83 return Err(format!(
84 "{path} is {} bytes, exceeding the artifact limit of {max} bytes",
85 bytes.len()
86 ));
87 }
88 let display = name
89 .map(str::to_string)
90 .filter(|n| !n.trim().is_empty())
91 .unwrap_or_else(|| file_name_of(path));
92 let safe = sanitize_file_name(&display);
93 let content_type = content_type_for(&safe);
94 let id = Uuid::now_v7();
95 let key = format!("agent/artifacts/{}/{id}/{safe}", env.run_id);
96 let client = env.state.storage.client();
97 client
98 .put_with_content_type(&key, &bytes, content_type)
99 .await
100 .map_err(|e| e.to_string())?;
101 let row = persist::insert_artifact(
102 env.db(),
103 env.run_id,
104 &display,
105 path,
106 client.bucket_name(),
107 &key,
108 bytes.len() as i64,
109 content_type,
110 source,
111 )
112 .await
113 .map_err(|e| e.to_string())?;
114 Ok(row)
115}
116
117pub fn file_name_of(path: &str) -> String {
118 path.rsplit('/')
119 .find(|part| !part.is_empty())
120 .unwrap_or("artifact")
121 .to_string()
122}
123
124pub fn sanitize_file_name(name: &str) -> String {
125 let cleaned: String = name
126 .chars()
127 .map(|c| match c {
128 'a'..='z' | 'A'..='Z' | '0'..='9' | '.' | '_' | '-' => c,
129 _ => '_',
130 })
131 .take(128)
132 .collect();
133 let trimmed = cleaned.trim_matches('.');
134 if trimmed.is_empty() {
135 "artifact".to_string()
136 } else {
137 trimmed.to_string()
138 }
139}
140
141pub fn content_type_for(name: &str) -> &'static str {
142 let ext = name.rsplit('.').next().unwrap_or("").to_lowercase();
143 match ext.as_str() {
144 "txt" | "log" => "text/plain",
145 "md" => "text/markdown",
146 "csv" => "text/csv",
147 "json" => "application/json",
148 "html" | "htm" => "text/html",
149 "xml" => "application/xml",
150 "yaml" | "yml" => "text/yaml",
151 "toml" => "text/toml",
152 "png" => "image/png",
153 "jpg" | "jpeg" => "image/jpeg",
154 "gif" => "image/gif",
155 "webp" => "image/webp",
156 "svg" => "image/svg+xml",
157 "pdf" => "application/pdf",
158 "zip" => "application/zip",
159 "gz" | "tgz" => "application/gzip",
160 "tar" => "application/x-tar",
161 _ => "application/octet-stream",
162 }
163}
Deleted lib/agent/src/tools/files.rs lib/agent/src/tools/files.rs +0 −146
@@ -1,146 +0,0 @@
1use std::sync::Arc;
2
3use rig::tool::{DynamicTool, ToolExecutionError, ToolOutput};
4use serde::Deserialize;
5use serde_json::json;
6
7use super::{ToolEnv, truncate_output};
8
9pub fn read_tool(env: Arc<ToolEnv>) -> DynamicTool {
10 DynamicTool::new(
11 "sandbox_read_file",
12 "Read a text file from the sandbox filesystem.",
13 json!({
14 "type": "object",
15 "properties": {
16 "path": {
17 "type": "string",
18 "description": "Absolute path of the file inside the sandbox"
19 }
20 },
21 "required": ["path"]
22 }),
23 move |_ctx, args| {
24 let env = env.clone();
25 Box::pin(async move {
26 #[derive(Deserialize)]
27 struct Args {
28 path: String,
29 }
30 let a: Args = serde_json::from_value(args)
31 .map_err(|e| ToolExecutionError::invalid_args(e.to_string()))?;
32 let max = env.limits().tool_output_max_bytes;
33 match env.sandbox.files().read(&a.path).await {
34 Ok(content) => {
35 let (content, truncated) = truncate_output(&content, max);
36 Ok(ToolOutput::json(json!({
37 "path": a.path,
38 "content": content,
39 "truncated": truncated,
40 })))
41 }
42 Err(e) => Err(map_file_error(e)),
43 }
44 })
45 },
46 )
47}
48
49pub fn write_tool(env: Arc<ToolEnv>) -> DynamicTool {
50 DynamicTool::new(
51 "sandbox_write_file",
52 "Write content to a file in the sandbox filesystem, creating or overwriting it.",
53 json!({
54 "type": "object",
55 "properties": {
56 "path": {
57 "type": "string",
58 "description": "Absolute path of the file inside the sandbox"
59 },
60 "content": {
61 "type": "string",
62 "description": "Full file content to write"
63 }
64 },
65 "required": ["path", "content"]
66 }),
67 move |_ctx, args| {
68 let env = env.clone();
69 Box::pin(async move {
70 #[derive(Deserialize)]
71 struct Args {
72 path: String,
73 content: String,
74 }
75 let a: Args = serde_json::from_value(args)
76 .map_err(|e| ToolExecutionError::invalid_args(e.to_string()))?;
77 let bytes = a.content.len();
78 match env
79 .sandbox
80 .files()
81 .write(&a.path, a.content.as_bytes())
82 .await
83 {
84 Ok(()) => Ok(ToolOutput::json(json!({
85 "path": a.path,
86 "bytes": bytes,
87 }))),
88 Err(e) => Err(map_file_error(e)),
89 }
90 })
91 },
92 )
93}
94
95pub fn list_tool(env: Arc<ToolEnv>) -> DynamicTool {
96 DynamicTool::new(
97 "sandbox_list_files",
98 "List files and directories at a path in the sandbox filesystem.",
99 json!({
100 "type": "object",
101 "properties": {
102 "path": {
103 "type": "string",
104 "description": "Absolute directory path inside the sandbox"
105 }
106 },
107 "required": ["path"]
108 }),
109 move |_ctx, args| {
110 let env = env.clone();
111 Box::pin(async move {
112 #[derive(Deserialize)]
113 struct Args {
114 path: String,
115 }
116 let a: Args = serde_json::from_value(args)
117 .map_err(|e| ToolExecutionError::invalid_args(e.to_string()))?;
118 match env.sandbox.files().list(&a.path).await {
119 Ok(entries) => {
120 let items: Vec<serde_json::Value> = entries
121 .iter()
122 .map(|e| {
123 json!({
124 "name": e.name,
125 "path": e.path,
126 "type": e.file_type,
127 "size": e.size,
128 })
129 })
130 .collect();
131 Ok(ToolOutput::json(json!({ "entries": items })))
132 }
133 Err(e) => Err(map_file_error(e)),
134 }
135 })
136 },
137 )
138}
139
140fn map_file_error(e: cubesandbox::Error) -> ToolExecutionError {
141 if e.is_sandbox_not_found() {
142 ToolExecutionError::not_found(e.to_string())
143 } else {
144 ToolExecutionError::other(e.to_string())
145 }
146}
Deleted lib/agent/src/tools/mod.rs lib/agent/src/tools/mod.rs +0 −51
@@ -1,51 +0,0 @@
1pub mod artifact;
2pub mod files;
3pub mod shell;
4
5use std::sync::Arc;
6
7use config::agent::AgentRuntimeConfig;
8use export::{AppDatabase, AppState};
9use rig::tool::DynamicTool;
10use uuid::Uuid;
11
12use crate::runtime::sink::EventEmitter;
13
14#[derive(Clone)]
15pub struct ToolEnv {
16 pub sandbox: cubesandbox::Sandbox,
17 pub state: AppState,
18 pub run_id: Uuid,
19 pub emitter: EventEmitter,
20}
21
22impl ToolEnv {
23 pub fn db(&self) -> &AppDatabase {
24 &self.state.database
25 }
26
27 pub fn limits(&self) -> &AgentRuntimeConfig {
28 &self.state.config.agent.runtime
29 }
30}
31
32pub fn build_tools(env: Arc<ToolEnv>) -> Vec<DynamicTool> {
33 vec![
34 shell::shell_tool(env.clone()),
35 files::read_tool(env.clone()),
36 files::write_tool(env.clone()),
37 files::list_tool(env.clone()),
38 artifact::artifact_tool(env),
39 ]
40}
41
42pub fn truncate_output(s: &str, max_bytes: usize) -> (String, bool) {
43 if s.len() <= max_bytes {
44 return (s.to_string(), false);
45 }
46 let mut end = max_bytes;
47 while end > 0 && !s.is_char_boundary(end) {
48 end -= 1;
49 }
50 (s[..end].to_string(), true)
51}
Deleted lib/agent/src/tools/shell.rs lib/agent/src/tools/shell.rs +0 −65
@@ -1,65 +0,0 @@
1use std::sync::Arc;
2use std::time::Duration;
3
4use cubesandbox::CommandOptions;
5use rig::tool::{DynamicTool, ToolExecutionError, ToolOutput};
6use serde::Deserialize;
7use serde_json::json;
8
9use super::{ToolEnv, truncate_output};
10
11pub fn shell_tool(env: Arc<ToolEnv>) -> DynamicTool {
12 DynamicTool::new(
13 "sandbox_shell",
14 "Run a shell command inside the isolated sandbox and return its stdout, stderr and exit_code. Non-zero exit codes are reported as normal results, not failures.",
15 json!({
16 "type": "object",
17 "properties": {
18 "command": {
19 "type": "string",
20 "description": "Shell command to execute"
21 },
22 "timeout_secs": {
23 "type": "integer",
24 "description": "Optional wall-clock limit in seconds (1-3600)"
25 }
26 },
27 "required": ["command"]
28 }),
29 move |_ctx, args| {
30 let env = env.clone();
31 Box::pin(async move {
32 #[derive(Deserialize)]
33 struct Args {
34 command: String,
35 timeout_secs: Option<u64>,
36 }
37 let a: Args = serde_json::from_value(args)
38 .map_err(|e| ToolExecutionError::invalid_args(e.to_string()))?;
39 if a.command.trim().is_empty() {
40 return Err(ToolExecutionError::invalid_args(
41 "command must not be empty",
42 ));
43 }
44 let mut opts = CommandOptions::new();
45 if let Some(secs) = a.timeout_secs {
46 opts = opts.timeout(Duration::from_secs(secs.clamp(1, 3600)));
47 }
48 let max = env.limits().tool_output_max_bytes;
49 match env.sandbox.commands().run(&a.command, &opts).await {
50 Ok(r) => {
51 let (stdout, out_truncated) = truncate_output(&r.stdout, max);
52 let (stderr, err_truncated) = truncate_output(&r.stderr, max);
53 Ok(ToolOutput::json(json!({
54 "stdout": stdout,
55 "stderr": stderr,
56 "exit_code": r.exit_code,
57 "truncated": out_truncated || err_truncated,
58 })))
59 }
60 Err(e) => Err(ToolExecutionError::other(e.to_string())),
61 }
62 })
63 },
64 )
65}
Deleted lib/agent/src/error.rs lib/agent/src/error.rs +0 −25
@@ -1,25 +0,0 @@
1use thiserror::Error;
2
3#[derive(Debug, Error)]
4pub enum AgentError {
5 #[error("invalid agent configuration: {0}")]
6 Config(String),
7 #[error("provider error: {0}")]
8 Provider(String),
9 #[error("sandbox error: {0}")]
10 Sandbox(#[from] cubesandbox::Error),
11 #[error("redis error: {0}")]
12 Redis(#[from] redis::RedisError),
13 #[error("database error: {0}")]
14 Db(#[from] sea_orm::DbErr),
15 #[error("storage error: {0}")]
16 Storage(String),
17 #[error("not found: {0}")]
18 NotFound(String),
19 #[error("conflict: {0}")]
20 Conflict(String),
21 #[error("internal error: {0}")]
22 Internal(String),
23}
24
25pub type Result<T> = std::result::Result<T, AgentError>;
Deleted lib/agent/src/lib.rs lib/agent/src/lib.rs +0 −3
@@ -1,3 +0,0 @@
1pub mod error;
2pub mod runtime;
3pub mod tools;
Deleted lib/agent/Cargo.toml lib/agent/Cargo.toml +0 −21
@@ -1,21 +0,0 @@
1[package]
2name = "agent"
3version.workspace = true
4edition.workspace = true
5
6[dependencies]
7rig = { workspace = true }
8cubesandbox = { workspace = true }
9config = { workspace = true }
10export = { workspace = true }
11models = { workspace = true }
12tokio = { workspace = true, features = ["macros", "rt-multi-thread", "sync", "time"] }
13futures = { workspace = true }
14serde = { workspace = true, features = ["derive"] }
15serde_json = { workspace = true }
16sea-orm = { workspace = true }
17redis = { workspace = true }
18thiserror = { workspace = true }
19tracing = { workspace = true }
20uuid = { workspace = true }
21time = { workspace = true }
Deleted lib/config/src/agent.rs lib/config/src/agent.rs +0 −182
@@ -1,182 +0,0 @@
1use serde::Deserialize;
2
3#[derive(Clone, Debug, Default, Deserialize)]
4#[serde(default)]
5pub struct AgentProviderConfig {
6 pub base_url: String,
7 pub api_key: String,
8 pub model: String,
9}
10
11#[derive(Clone, Debug, Deserialize)]
12#[serde(default)]
13pub struct AgentSandboxConfig {
14 pub api_url: String,
15 pub api_key: String,
16 pub template_id: String,
17 pub timeout_secs: u64,
18 pub lease_secs: u64,
19}
20
21impl Default for AgentSandboxConfig {
22 fn default() -> Self {
23 Self {
24 api_url: String::new(),
25 api_key: String::new(),
26 template_id: String::new(),
27 timeout_secs: 3600,
28 lease_secs: 600,
29 }
30 }
31}
32
33#[derive(Clone, Debug, Deserialize)]
34#[serde(default)]
35pub struct AgentRuntimeConfig {
36 pub default_max_turns: usize,
37 pub event_stream_maxlen: u64,
38 pub event_ttl_secs: u64,
39 pub tool_output_max_bytes: usize,
40 pub artifact_max_size: i64,
41 pub artifact_dir: String,
42 pub context_max_tokens: usize,
43 pub compact_keep_recent: usize,
44}
45
46impl Default for AgentRuntimeConfig {
47 fn default() -> Self {
48 Self {
49 default_max_turns: 32,
50 event_stream_maxlen: 10_000,
51 event_ttl_secs: 86_400,
52 tool_output_max_bytes: 32_768,
53 artifact_max_size: 104_857_600,
54 artifact_dir: String::new(),
55 context_max_tokens: 128_000,
56 compact_keep_recent: 16,
57 }
58 }
59}
60
61#[derive(Clone, Debug, Deserialize)]
62#[serde(default)]
63pub struct AgentQueueConfig {
64 pub stream: String,
65 pub subject: String,
66 pub durable: String,
67 pub concurrency: usize,
68 pub ack_wait_secs: u64,
69 pub max_deliver: i64,
70 pub nak_delay_secs: u64,
71 pub drain_timeout_secs: u64,
72 pub sweep_interval_secs: u64,
73 pub stream_max_age_secs: u64,
74}
75
76impl Default for AgentQueueConfig {
77 fn default() -> Self {
78 Self {
79 stream: "AGENT".to_string(),
80 subject: "agent.run.execute".to_string(),
81 durable: "ai-executor".to_string(),
82 concurrency: 4,
83 ack_wait_secs: 7200,
84 max_deliver: 8,
85 nak_delay_secs: 30,
86 drain_timeout_secs: 120,
87 sweep_interval_secs: 300,
88 stream_max_age_secs: 86_400,
89 }
90 }
91}
92
93#[derive(Clone, Debug, Default, Deserialize)]
94#[serde(default)]
95pub struct AgentConfig {
96 pub provider: AgentProviderConfig,
97 pub sandbox: AgentSandboxConfig,
98 pub runtime: AgentRuntimeConfig,
99 pub queue: AgentQueueConfig,
100}
101
102impl AgentConfig {
103 pub fn is_enabled(&self) -> bool {
104 !self.provider.base_url.is_empty()
105 || !self.provider.model.is_empty()
106 || !self.sandbox.api_url.is_empty()
107 || !self.sandbox.template_id.is_empty()
108 }
109
110 pub fn is_valid(&self) -> Result<(), String> {
111 if !self.is_enabled() {
112 return Ok(());
113 }
114 if self.provider.base_url.is_empty() {
115 return Err("agent provider base_url must be set".to_string());
116 }
117 if self.provider.model.is_empty() {
118 return Err("agent provider model must be set".to_string());
119 }
120 if self.sandbox.api_url.is_empty() {
121 return Err("agent sandbox api_url must be set".to_string());
122 }
123 if self.sandbox.api_key.is_empty() {
124 return Err("agent sandbox api_key must be set".to_string());
125 }
126 if self.sandbox.template_id.is_empty() {
127 return Err("agent sandbox template_id must be set".to_string());
128 }
129 if self.sandbox.timeout_secs == 0 || self.sandbox.lease_secs == 0 {
130 return Err("agent sandbox timeouts must be positive".to_string());
131 }
132 if self.sandbox.lease_secs > self.sandbox.timeout_secs {
133 return Err("agent sandbox lease_secs must not exceed timeout_secs".to_string());
134 }
135 if self.runtime.default_max_turns == 0 {
136 return Err("agent runtime default_max_turns must be positive".to_string());
137 }
138 if self.runtime.event_stream_maxlen == 0 {
139 return Err("agent runtime event_stream_maxlen must be positive".to_string());
140 }
141 if self.runtime.tool_output_max_bytes == 0 {
142 return Err("agent runtime tool_output_max_bytes must be positive".to_string());
143 }
144 if self.runtime.artifact_max_size <= 0 {
145 return Err("agent runtime artifact_max_size must be positive".to_string());
146 }
147 if self.runtime.context_max_tokens == 0 {
148 return Err("agent runtime context_max_tokens must be positive".to_string());
149 }
150 if self.runtime.compact_keep_recent == 0 {
151 return Err("agent runtime compact_keep_recent must be positive".to_string());
152 }
153 if self.queue.stream.is_empty() {
154 return Err("agent queue stream must be set".to_string());
155 }
156 if self.queue.subject.is_empty() {
157 return Err("agent queue subject must be set".to_string());
158 }
159 if self.queue.durable.is_empty() {
160 return Err("agent queue durable must be set".to_string());
161 }
162 if self.queue.concurrency == 0 {
163 return Err("agent queue concurrency must be positive".to_string());
164 }
165 if self.queue.ack_wait_secs == 0 {
166 return Err("agent queue ack_wait_secs must be positive".to_string());
167 }
168 if self.queue.max_deliver <= 0 {
169 return Err("agent queue max_deliver must be positive".to_string());
170 }
171 if self.queue.drain_timeout_secs == 0 {
172 return Err("agent queue drain_timeout_secs must be positive".to_string());
173 }
174 if self.queue.sweep_interval_secs == 0 {
175 return Err("agent queue sweep_interval_secs must be positive".to_string());
176 }
177 if self.queue.stream_max_age_secs == 0 {
178 return Err("agent queue stream_max_age_secs must be positive".to_string());
179 }
180 Ok(())
181 }
182}
Modified lib/config/src/lib.rs lib/config/src/lib.rs +0 −7 View lib/config/src/lib.rs
@@ -1,4 +1,3 @@
1pub mod agent;
21pub mod apihost;
32pub mod auth;
43pub mod cache;
@@ -9,7 +8,6 @@
98pub mod git;
109pub mod githost;
1110pub mod issues;
12pub mod nats;
1311pub mod pow;
1412pub mod quota;
1513pub mod redis;
@@ -25,7 +23,6 @@
2523
2624pub use error::ConfigError;
2725
28use crate::agent::AgentConfig;
2926use crate::apihost::ApihostConfig;
3027use crate::auth::AuthConfig;
3128use crate::cache::CacheConfig;
@@ -36,7 +33,6 @@
3633use crate::git::GitConfig;
3734use crate::githost::GithostConfig;
3835use crate::issues::IssueConfig;
39use crate::nats::NatsConfig;
4036use crate::pow::PowConfig;
4137use crate::redis::RedisConfig;
4238use crate::s3::S3Config;
@@ -51,7 +47,6 @@
5147pub struct AppConfig {
5248 pub s3: S3Config,
5349 pub redis: RedisConfig,
54 pub nats: NatsConfig,
5550 pub cache: CacheConfig,
5651 pub chat: ChatConfig,
5752 pub database: DatabaseConfig,
@@ -68,7 +63,6 @@
6863 pub email_queue: EmailQueueConfig,
6964 pub apihost: ApihostConfig,
7065 pub githost: GithostConfig,
71 pub agent: AgentConfig,
7266}
7367
7468impl AppConfig {
@@ -90,7 +84,6 @@
9084 self.session.is_valid().map_err(ConfigError::Validation)?;
9185 self.apihost.is_valid().map_err(ConfigError::Validation)?;
9286 self.githost.is_valid().map_err(ConfigError::Validation)?;
93 self.agent.is_valid().map_err(ConfigError::Validation)?;
9487 Ok(())
9588 }
9689}
Deleted lib/config/src/nats.rs lib/config/src/nats.rs +0 −16
@@ -1,16 +0,0 @@
1use serde::Deserialize;
2
3#[derive(Clone, Debug, Default, Deserialize)]
4#[serde(default)]
5pub struct NatsConfig {
6 pub url: String,
7 pub token: String,
8 pub user: String,
9 pub password: String,
10}
11
12impl NatsConfig {
13 pub fn is_enabled(&self) -> bool {
14 !self.url.is_empty()
15 }
16}
Modified lib/config/src/scoped.rs lib/config/src/scoped.rs +0 −41 View lib/config/src/scoped.rs
@@ -1,7 +1,6 @@
11use serde::Deserialize;
22use serde::de::DeserializeOwned;
33
4use crate::agent::AgentConfig;
54use crate::apihost::ApihostConfig as ApihostSection;
65use crate::auth::AuthConfig;
76use crate::cache::CacheConfig;
@@ -13,7 +12,6 @@
1312use crate::git::GitConfig;
1413use crate::githost::GithostConfig as GithostSection;
1514use crate::issues::IssueConfig;
16use crate::nats::NatsConfig;
1715use crate::pow::PowConfig;
1816use crate::quota::QuotaConfig;
1917use crate::redis::RedisConfig;
@@ -76,45 +74,6 @@
7674 self.database.validate()?;
7775 self.redis.validate()?;
7876 self.cache.validate()
79 }
80}
81
82// s3/email/email_queue 由 AppState 构建时无条件消费（EmailConfig 缺省视为启用、
83// S3Client 对空 bucket 报错），即使业务路径不用也必须入域，否则装配即失败
84#[derive(Clone, Debug, Default, Deserialize)]
85#[serde(default)]
86pub struct AiConfig {
87 pub database: DatabaseConfig,
88 pub redis: RedisConfig,
89 pub s3: S3Config,
90 pub email: EmailConfig,
91 pub email_queue: EmailQueueConfig,
92 pub nats: NatsConfig,
93 pub agent: AgentConfig,
94}
95
96impl AiConfig {
97 pub fn into_app_config(self) -> AppConfig {
98 AppConfig {
99 database: self.database,
100 redis: self.redis,
101 s3: self.s3,
102 email: self.email,
103 email_queue: self.email_queue,
104 nats: self.nats,
105 agent: self.agent,
106 ..Default::default()
107 }
108 }
109}
110
111impl ScopedConfig for AiConfig {
112 fn validate_scoped(&self) -> Result<(), String> {
113 self.database.validate()?;
114 self.redis.validate()?;
115 self.email.is_valid()?;
116 self.email_queue.is_valid()?;
117 self.agent.is_valid()
11877 }
11978}
12079
Modified lib/export/src/lib.rs lib/export/src/lib.rs +0 −2 View lib/export/src/lib.rs
@@ -2,7 +2,6 @@
22pub mod error;
33pub mod health;
44pub mod middleware;
5pub mod nats;
65pub mod notify;
76pub mod pagination;
87pub mod redis;
@@ -14,7 +13,6 @@
1413use config::AppConfig;
1514pub use database::{AppDatabase, DatabaseRole};
1615pub use error::ExportError;
17pub use nats::AppNats;
1816pub use redis::{AppRedis, RedisConnection};
1917pub use storage::AppStorage;
2018
Deleted lib/export/src/nats.rs lib/export/src/nats.rs +0 −41
@@ -1,41 +0,0 @@
1use config::nats::NatsConfig;
2
3use crate::error::ExportError;
4
5#[derive(Clone)]
6pub struct AppNats {
7 client: async_nats::Client,
8}
9
10impl AppNats {
11 pub async fn connect(cfg: &NatsConfig) -> Result<Self, ExportError> {
12 if cfg.url.is_empty() {
13 return Err(ExportError::InvalidConfig(
14 "nats url must be set".to_string(),
15 ));
16 }
17 let options = if !cfg.token.is_empty() {
18 async_nats::ConnectOptions::with_token(cfg.token.clone())
19 } else if !cfg.user.is_empty() {
20 async_nats::ConnectOptions::with_user_and_password(
21 cfg.user.clone(),
22 cfg.password.clone(),
23 )
24 } else {
25 async_nats::ConnectOptions::new()
26 };
27 let client = options
28 .connect(cfg.url.clone())
29 .await
30 .map_err(|e| ExportError::Connection(format!("nats: {e}")))?;
31 Ok(Self { client })
32 }
33
34 pub fn client(&self) -> &async_nats::Client {
35 &self.client
36 }
37
38 pub fn jetstream(&self) -> async_nats::jetstream::Context {
39 async_nats::jetstream::new(self.client.clone())
40 }
41}
Modified lib/export/Cargo.toml lib/export/Cargo.toml +0 −1 View lib/export/Cargo.toml
@@ -8,7 +8,6 @@
88storage = { workspace = true }
99sea-orm = { workspace = true }
1010redis = { workspace = true }
11async-nats = { workspace = true }
1211tokio = { workspace = true }
1312email = { workspace = true }
1413axum = { workspace = true }
Deleted lib/models/src/agent/agent.rs lib/models/src/agent/agent.rs +0 −23
@@ -1,23 +0,0 @@
1use sea_orm::entity::prelude::*;
2use time::OffsetDateTime;
3use uuid::Uuid;
4
5#[sea_orm::model]
6#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
7#[sea_orm(table_name = "agent")]
8pub struct Model {
9 #[sea_orm(primary_key, auto_increment = false)]
10 pub id: Uuid,
11 #[sea_orm(unique)]
12 pub dir_id: Uuid,
13 pub name: String,
14 pub icon: Option<String>,
15 pub description: Option<String>,
16 pub preamble: Option<String>,
17 pub created_at: OffsetDateTime,
18 pub updated_at: Option<OffsetDateTime>,
19 #[sea_orm(belongs_to, from = "dir_id", to = "id")]
20 pub dir: BelongsTo<super::super::dir::dirs::Entity>,
21}
22
23impl ActiveModelBehavior for ActiveModel {}
Deleted lib/models/src/agent/artifact.rs lib/models/src/agent/artifact.rs +0 −50
@@ -1,50 +0,0 @@
1use sea_orm::entity::prelude::*;
2use serde::{Deserialize, Serialize};
3use time::OffsetDateTime;
4use uuid::Uuid;
5
6#[derive(
7 Debug,
8 Clone,
9 Copy,
10 PartialEq,
11 Eq,
12 Default,
13 EnumIter,
14 DeriveActiveEnum,
15 Serialize,
16 Deserialize,
17 utoipa::ToSchema,
18)]
19#[serde(rename_all = "snake_case")]
20#[sea_orm(rs_type = "i16", db_type = "SmallInteger")]
21pub enum AgentArtifactSource {
22 #[default]
23 #[sea_orm(num_value = 0)]
24 Tool,
25 #[sea_orm(num_value = 1)]
26 Sweep,
27}
28
29#[sea_orm::model]
30#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
31#[sea_orm(table_name = "agent_artifact")]
32pub struct Model {
33 #[sea_orm(primary_key, auto_increment = false)]
34 pub id: Uuid,
35 #[sea_orm(indexed)]
36 pub run_id: Uuid,
37 pub name: String,
38 pub sandbox_path: String,
39 pub bucket: String,
40 pub s3_key: String,
41 pub size: i64,
42 pub content_type: String,
43 #[sea_orm(default_value = 0)]
44 pub source: AgentArtifactSource,
45 pub created_at: OffsetDateTime,
46 #[sea_orm(belongs_to, from = "run_id", to = "id")]
47 pub run: BelongsTo<super::run::Entity>,
48}
49
50impl ActiveModelBehavior for ActiveModel {}
Deleted lib/models/src/agent/conversation.rs lib/models/src/agent/conversation.rs +0 −27
@@ -1,27 +0,0 @@
1use sea_orm::JsonValue;
2use sea_orm::entity::prelude::*;
3use time::OffsetDateTime;
4use uuid::Uuid;
5
6#[sea_orm::model]
7#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
8#[sea_orm(table_name = "agent_conversation")]
9pub struct Model {
10 #[sea_orm(primary_key, auto_increment = false)]
11 pub id: Uuid,
12 #[sea_orm(unique_key = "agent_number")]
13 pub agent_id: Uuid,
14 #[sea_orm(unique_key = "agent_number")]
15 pub autoincrement_id: i32,
16 pub title: Option<String>,
17 #[sea_orm(column_type = "JsonBinary", default_value = "[]")]
18 pub history: JsonValue,
19 pub last_run_at: Option<OffsetDateTime>,
20 pub closed_at: Option<OffsetDateTime>,
21 pub created_at: OffsetDateTime,
22 pub updated_at: Option<OffsetDateTime>,
23 #[sea_orm(belongs_to, from = "agent_id", to = "id")]
24 pub agent: BelongsTo<super::agent::Entity>,
25}
26
27impl ActiveModelBehavior for ActiveModel {}
Deleted lib/models/src/agent/mod.rs lib/models/src/agent/mod.rs +0 −7
@@ -1,7 +0,0 @@
1#![allow(clippy::module_inception)]
2
3pub mod agent;
4pub mod artifact;
5pub mod conversation;
6pub mod run;
7pub mod sandbox;
Deleted lib/models/src/agent/run.rs lib/models/src/agent/run.rs +0 −62
@@ -1,62 +0,0 @@
1use sea_orm::JsonValue;
2use sea_orm::entity::prelude::*;
3use serde::{Deserialize, Serialize};
4use time::OffsetDateTime;
5use uuid::Uuid;
6
7#[derive(
8 Debug,
9 Clone,
10 Copy,
11 PartialEq,
12 Eq,
13 Default,
14 EnumIter,
15 DeriveActiveEnum,
16 Serialize,
17 Deserialize,
18 utoipa::ToSchema,
19)]
20#[serde(rename_all = "snake_case")]
21#[sea_orm(rs_type = "i16", db_type = "SmallInteger")]
22pub enum AgentRunState {
23 #[default]
24 #[sea_orm(num_value = 0)]
25 Queued,
26 #[sea_orm(num_value = 1)]
27 Running,
28 #[sea_orm(num_value = 2)]
29 Success,
30 #[sea_orm(num_value = 3)]
31 Failure,
32 #[sea_orm(num_value = 4)]
33 CancelRequested,
34 #[sea_orm(num_value = 5)]
35 Cancelled,
36}
37
38#[sea_orm::model]
39#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
40#[sea_orm(table_name = "agent_run")]
41pub struct Model {
42 #[sea_orm(primary_key, auto_increment = false)]
43 pub id: Uuid,
44 #[sea_orm(indexed)]
45 pub conversation_id: Uuid,
46 #[sea_orm(default_value = 0)]
47 pub state: AgentRunState,
48 pub prompt: String,
49 pub final_text: Option<String>,
50 #[sea_orm(column_type = "JsonBinary", default_value = "{}")]
51 pub usage: JsonValue,
52 pub error: Option<String>,
53 pub sandbox_id: Option<String>,
54 pub started_at: Option<OffsetDateTime>,
55 pub finished_at: Option<OffsetDateTime>,
56 pub created_at: OffsetDateTime,
57 pub updated_at: OffsetDateTime,
58 #[sea_orm(belongs_to, from = "conversation_id", to = "id")]
59 pub conversation: BelongsTo<super::conversation::Entity>,
60}
61
62impl ActiveModelBehavior for ActiveModel {}
Deleted lib/models/src/agent/sandbox.rs lib/models/src/agent/sandbox.rs +0 −55
@@ -1,55 +0,0 @@
1use sea_orm::entity::prelude::*;
2use serde::{Deserialize, Serialize};
3use time::OffsetDateTime;
4use uuid::Uuid;
5
6#[derive(
7 Debug,
8 Clone,
9 Copy,
10 PartialEq,
11 Eq,
12 Default,
13 EnumIter,
14 DeriveActiveEnum,
15 Serialize,
16 Deserialize,
17 utoipa::ToSchema,
18)]
19#[serde(rename_all = "snake_case")]
20#[sea_orm(rs_type = "i16", db_type = "SmallInteger")]
21pub enum AgentSandboxState {
22 #[default]
23 #[sea_orm(num_value = 0)]
24 Creating,
25 #[sea_orm(num_value = 1)]
26 Active,
27 #[sea_orm(num_value = 2)]
28 Killing,
29 #[sea_orm(num_value = 3)]
30 Killed,
31 #[sea_orm(num_value = 4)]
32 Lost,
33}
34
35#[sea_orm::model]
36#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
37#[sea_orm(table_name = "agent_sandbox")]
38pub struct Model {
39 #[sea_orm(primary_key, auto_increment = false)]
40 pub id: Uuid,
41 #[sea_orm(indexed)]
42 pub run_id: Uuid,
43 pub sandbox_id: String,
44 pub template_id: String,
45 #[sea_orm(default_value = 0)]
46 pub state: AgentSandboxState,
47 pub lease_expires_at: OffsetDateTime,
48 pub last_heartbeat_at: Option<OffsetDateTime>,
49 pub created_at: OffsetDateTime,
50 pub killed_at: Option<OffsetDateTime>,
51 #[sea_orm(belongs_to, from = "run_id", to = "id")]
52 pub run: BelongsTo<super::run::Entity>,
53}
54
55impl ActiveModelBehavior for ActiveModel {}
Modified lib/models/src/lib.rs lib/models/src/lib.rs +0 −1 View lib/models/src/lib.rs
@@ -1,4 +1,3 @@
1pub mod agent;
21pub mod chat;
32pub mod common;
43pub mod dir;
Modified lib/models/schema_extras.sql lib/models/schema_extras.sql +0 −11 View lib/models/schema_extras.sql
@@ -262,14 +262,3 @@
262262 CHECK ((has_merged = false) OR merged_at IS NOT NULL);
263263 END IF;
264264END $$;
265
266-- agent
267
268CREATE INDEX IF NOT EXISTS idx_agent_run_conversation
269 ON agent_run (conversation_id, created_at);
270
271CREATE INDEX IF NOT EXISTS idx_agent_run_state
272 ON agent_run (state, created_at);
273
274CREATE INDEX IF NOT EXISTS idx_agent_sandbox_lease
275 ON agent_sandbox (state, lease_expires_at);
Modified Cargo.lock Cargo.lock +1015 −5109 View Cargo.lock
@@ -87,27 +87,6 @@
8787]
8888
8989[[package]]
90name = "agent"
91version = "1.0.0"
92dependencies = [
93 "config",
94 "cubesandbox",
95 "export",
96 "futures",
97 "models",
98 "redis",
99 "rig",
100 "sea-orm",
101 "serde",
102 "serde_json",
103 "thiserror 2.0.20",
104 "time 0.3.55",
105 "tokio",
106 "tracing",
107 "uuid",
108]
109
110[[package]]
11190name = "ahash"
11291version = "0.7.8"
11392source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -128,7 +107,6 @@
128107 "const-random",
129108 "getrandom 0.3.4",
130109 "once_cell",
131 "serde",
132110 "version_check 0.9.5",
133111 "zerocopy",
134112]
@@ -143,65 +121,12 @@
143121]
144122
145123[[package]]
146name = "ai"
147version = "1.0.0"
148dependencies = [
149 "agent",
150 "anyhow",
151 "async-nats",
152 "config",
153 "export",
154 "futures",
155 "models",
156 "sea-orm",
157 "serde_json",
158 "tokio",
159 "tokio-util",
160 "tracing",
161 "tracing-subscriber",
162 "uuid",
163]
164
165[[package]]
166124name = "aliasable"
167125version = "0.1.3"
168126source = "registry+https://github.com/rust-lang/crates.io-index"
169127checksum = "250f629c0161ad8107cf89319e990051fae62832fd343083bea452d93e2205fd"
170128
171129[[package]]
172name = "aligned"
173version = "0.4.3"
174source = "registry+https://github.com/rust-lang/crates.io-index"
175checksum = "ee4508988c62edf04abd8d92897fca0c2995d907ce1dfeaf369dac3716a40685"
176dependencies = [
177 "as-slice",
178]
179
180[[package]]
181name = "aligned-vec"
182version = "0.6.4"
183source = "registry+https://github.com/rust-lang/crates.io-index"
184checksum = "dc890384c8602f339876ded803c97ad529f3842aba97f6392b3dba0dd171769b"
185dependencies = [
186 "equator",
187]
188
189[[package]]
190name = "alloc-no-stdlib"
191version = "2.0.4"
192source = "registry+https://github.com/rust-lang/crates.io-index"
193checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3"
194
195[[package]]
196name = "alloc-stdlib"
197version = "0.2.4"
198source = "registry+https://github.com/rust-lang/crates.io-index"
199checksum = "0e76a019e91224d279006ff972f1e984179a6e9feb050adba6ce8274aef23195"
200dependencies = [
201 "alloc-no-stdlib",
202]
203
204[[package]]
205130name = "allocator-api2"
206131version = "0.2.21"
207132source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -281,35 +206,18 @@
281206checksum = "03918c3dbd7701a85c6b9887732e2921175f26c350b4563841d0958c21d57e6d"
282207
283208[[package]]
284name = "arg_enum_proc_macro"
285version = "0.3.4"
286source = "registry+https://github.com/rust-lang/crates.io-index"
287checksum = "0ae92a5119aa49cdbcf6b9f893fe4e1d98b04ccbf82ee0584ad948a44a734dea"
288dependencies = [
289 "proc-macro2",
290 "quote",
291 "syn 2.0.119",
292]
293
294[[package]]
295209name = "argon2"
296210version = "0.6.0"
297211source = "registry+https://github.com/rust-lang/crates.io-index"
298212checksum = "134c52ddac6d63c576bef8168db10c83c49c26444ecbc68060fef078925a901c"
299213dependencies = [
300214 "base64ct",
301 "blake2 0.11.0",
215 "blake2",
302216 "cpufeatures 0.3.0",
303217 "password-hash",
304218]
305219
306220[[package]]
307name = "arrayref"
308version = "0.3.9"
309source = "registry+https://github.com/rust-lang/crates.io-index"
310checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"
311
312[[package]]
313221name = "arrayvec"
314222version = "0.7.8"
315223source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -325,10 +233,7 @@
325233 "arrow-array",
326234 "arrow-buffer",
327235 "arrow-cast",
328 "arrow-csv",
329236 "arrow-data",
330 "arrow-ipc",
331 "arrow-json",
332237 "arrow-ord",
333238 "arrow-row",
334239 "arrow-schema",
@@ -361,7 +266,6 @@
361266 "arrow-data",
362267 "arrow-schema",
363268 "chrono",
364 "chrono-tz",
365269 "half",
366270 "hashbrown 0.17.1",
367271 "num-complex",
@@ -396,7 +300,6 @@
396300 "atoi",
397301 "base64 0.22.1",
398302 "chrono",
399 "comfy-table",
400303 "half",
401304 "lexical-core",
402305 "num-traits",
@@ -404,21 +307,6 @@
404307]
405308
406309[[package]]
407name = "arrow-csv"
408version = "58.4.0"
409source = "registry+https://github.com/rust-lang/crates.io-index"
410checksum = "af0dd6d90d1955e9f9a014c1e563ee8aeffc21909085d25623e1da44d96eca26"
411dependencies = [
412 "arrow-array",
413 "arrow-cast",
414 "arrow-schema",
415 "chrono",
416 "csv",
417 "csv-core",
418 "regex",
419]
420
421[[package]]
422310name = "arrow-data"
423311version = "58.4.0"
424312source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -432,47 +320,6 @@
432320]
433321
434322[[package]]
435name = "arrow-ipc"
436version = "58.4.0"
437source = "registry+https://github.com/rust-lang/crates.io-index"
438checksum = "29a908a11fcfb3fb2f6730f4ac15e367bc644e419155e96238f68cf3adde572b"
439dependencies = [
440 "arrow-array",
441 "arrow-buffer",
442 "arrow-data",
443 "arrow-schema",
444 "arrow-select",
445 "flatbuffers",
446 "lz4_flex",
447 "zstd",
448]
449
450[[package]]
451name = "arrow-json"
452version = "58.4.0"
453source = "registry+https://github.com/rust-lang/crates.io-index"
454checksum = "b8a96aed3931c076adee39ec2a40d8219fc7f09e79bcdaca1df16272993e1e14"
455dependencies = [
456 "arrow-array",
457 "arrow-buffer",
458 "arrow-cast",
459 "arrow-ord",
460 "arrow-schema",
461 "arrow-select",
462 "chrono",
463 "half",
464 "indexmap 2.14.0",
465 "itoa",
466 "lexical-core",
467 "memchr",
468 "num-traits",
469 "ryu",
470 "serde_core",
471 "serde_json",
472 "simdutf8",
473]
474
475[[package]]
476323name = "arrow-ord"
477324version = "58.4.0"
478325source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -503,11 +350,6 @@
503350version = "58.4.0"
504351source = "registry+https://github.com/rust-lang/crates.io-index"
505352checksum = "21ca356ad6425cecb6eb7b28e4f659f1ee7880fbb1a16127de7dd62901efee9e"
506dependencies = [
507 "bitflags 2.13.1",
508 "serde_core",
509 "serde_json",
510]
511353
512354[[package]]
513355name = "arrow-select"
@@ -541,51 +383,12 @@
541383]
542384
543385[[package]]
544name = "as-any"
545version = "0.3.2"
546source = "registry+https://github.com/rust-lang/crates.io-index"
547checksum = "b0f477b951e452a0b6b4a10b53ccd569042d1d01729b519e02074a9c0958a063"
548
549[[package]]
550name = "as-slice"
551version = "0.2.1"
552source = "registry+https://github.com/rust-lang/crates.io-index"
553checksum = "516b6b4f0e40d50dcda9365d53964ec74560ad4284da2e7fc97122cd83174516"
554dependencies = [
555 "stable_deref_trait",
556]
557
558[[package]]
559386name = "ascii_utils"
560387version = "0.9.3"
561388source = "registry+https://github.com/rust-lang/crates.io-index"
562389checksum = "71938f30533e4d95a6d17aa530939da3842c2ab6f4f84b9dae68447e4129f74a"
563390
564391[[package]]
565name = "async-channel"
566version = "2.5.0"
567source = "registry+https://github.com/rust-lang/crates.io-index"
568checksum = "924ed96dd52d1b75e9c1a3e6275715fd320f5f9439fb5a4a11fa51f4221158d2"
569dependencies = [
570 "concurrent-queue",
571 "event-listener-strategy",
572 "futures-core",
573 "pin-project-lite",
574]
575
576[[package]]
577name = "async-compression"
578version = "0.4.45"
579source = "registry+https://github.com/rust-lang/crates.io-index"
580checksum = "24a8ec73eb862508b7041723c89386365894b4e7d9f6998bf1b8529e5b0ee254"
581dependencies = [
582 "compression-codecs",
583 "compression-core",
584 "pin-project-lite",
585 "tokio",
586]
587
588[[package]]
589392name = "async-graphql"
590393version = "7.2.1"
591394source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -604,7 +407,7 @@
604407 "futures-util",
605408 "handlebars",
606409 "http 1.5.0",
607 "indexmap 2.14.0",
410 "indexmap",
608411 "mime 0.3.17",
609412 "multer",
610413 "num-traits",
@@ -654,7 +457,7 @@
654457checksum = "3e3ef112905abea9dea592fc868a6873b10ebd3f983e83308f995d6284e9ba41"
655458dependencies = [
656459 "bytes",
657 "indexmap 2.14.0",
460 "indexmap",
658461 "serde",
659462 "serde_json",
660463]
@@ -689,53 +492,6 @@
689492]
690493
691494[[package]]
692name = "async-nats"
693version = "0.50.0"
694source = "registry+https://github.com/rust-lang/crates.io-index"
695checksum = "d83a251fa1a4c9d0fe6e816b7acd60549e473e08d14f27a1d992c2675abff05f"
696dependencies = [
697 "base64 0.22.1",
698 "bytes",
699 "futures-util",
700 "memchr",
701 "nkeys",
702 "nuid",
703 "pin-project",
704 "portable-atomic",
705 "rand 0.10.2",
706 "regex",
707 "ring",
708 "rustls-native-certs",
709 "rustls-pki-types",
710 "rustls-webpki",
711 "serde",
712 "serde_json",
713 "serde_nanos",
714 "serde_repr",
715 "thiserror 2.0.20",
716 "time 0.3.55",
717 "tokio",
718 "tokio-rustls",
719 "tokio-stream",
720 "tokio-util",
721 "tokio-websockets",
722 "tracing",
723 "tryhard",
724 "url 2.5.8",
725]
726
727[[package]]
728name = "async-recursion"
729version = "1.1.1"
730source = "registry+https://github.com/rust-lang/crates.io-index"
731checksum = "3b43422f69d8ff38f95f1b2bb76517c91589a924d1559a0e935d7c8ce0274c11"
732dependencies = [
733 "proc-macro2",
734 "quote",
735 "syn 2.0.119",
736]
737
738[[package]]
739495name = "async-stream"
740496version = "0.3.6"
741497source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -769,15 +525,6 @@
769525]
770526
771527[[package]]
772name = "async_cell"
773version = "0.2.3"
774source = "registry+https://github.com/rust-lang/crates.io-index"
775checksum = "447ab28afbb345f5408b120702a44e5529ebf90b1796ec76e9528df8e288e6c2"
776dependencies = [
777 "loom",
778]
779
780[[package]]
781528name = "asynk-strim"
782529version = "0.1.5"
783530source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -867,56 +614,13 @@
867614checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
868615
869616[[package]]
870name = "av-scenechange"
871version = "0.14.1"
872source = "registry+https://github.com/rust-lang/crates.io-index"
873checksum = "0f321d77c20e19b92c39e7471cf986812cbb46659d2af674adc4331ef3f18394"
874dependencies = [
875 "aligned",
876 "anyhow",
877 "arg_enum_proc_macro",
878 "arrayvec",
879 "log 0.4.33",
880 "num-rational",
881 "num-traits",
882 "pastey 0.1.1",
883 "rayon",
884 "thiserror 2.0.20",
885 "v_frame",
886 "y4m",
887]
888
889[[package]]
890name = "av1-grain"
891version = "0.2.5"
892source = "registry+https://github.com/rust-lang/crates.io-index"
893checksum = "8cfddb07216410377231960af4fcab838eaa12e013417781b78bd95ee22077f8"
894dependencies = [
895 "anyhow",
896 "arrayvec",
897 "log 0.4.33",
898 "nom 8.0.0",
899 "num-rational",
900 "v_frame",
901]
902
903[[package]]
904name = "avif-serialize"
905version = "0.8.9"
906source = "registry+https://github.com/rust-lang/crates.io-index"
907checksum = "e7178fe5f7d460b13895ebb9dcb28a3a6216d2df2574a0806cb51b555d297f38"
908dependencies = [
909 "arrayvec",
910]
911
912[[package]]
913617name = "aws-creds"
914618version = "0.35.0"
915619source = "registry+https://github.com/rust-lang/crates.io-index"
916620checksum = "01eb8a458c003bd8fe37badba2d8a5a3839748b6ade5cc2d92c2c6b9c6d5a437"
917621dependencies = [
918622 "attohttpc",
919 "dirs 5.0.1",
623 "dirs",
920624 "log 0.4.33",
921625 "quick-xml",
922626 "rust-ini",
@@ -1093,12 +797,6 @@
1093797
1094798[[package]]
1095799name = "base64"
1096version = "0.13.1"
1097source = "registry+https://github.com/rust-lang/crates.io-index"
1098checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
1099
1100[[package]]
1101name = "base64"
1102800version = "0.21.7"
1103801source = "registry+https://github.com/rust-lang/crates.io-index"
1104802checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
@@ -1162,12 +860,6 @@
1162860checksum = "d21f40d350a700f6aa107e45fb26448cf489d34794b2ba4522181dc9f1173af6"
1163861
1164862[[package]]
1165name = "bit_field"
1166version = "0.10.3"
1167source = "registry+https://github.com/rust-lang/crates.io-index"
1168checksum = "1e4b40c7323adcfc0a41c4b88143ed58346ff65a288fc144329c5c45e05d70c6"
1169
1170[[package]]
1171863name = "bitflags"
1172864version = "1.3.2"
1173865source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1183,24 +875,6 @@
1183875]
1184876
1185877[[package]]
1186name = "bitpacking"
1187version = "0.9.3"
1188source = "registry+https://github.com/rust-lang/crates.io-index"
1189checksum = "96a7139abd3d9cebf8cd6f920a389cf3dc9576172e32f4563f188cae3c3eb019"
1190dependencies = [
1191 "crunchy",
1192]
1193
1194[[package]]
1195name = "bitstream-io"
1196version = "4.10.0"
1197source = "registry+https://github.com/rust-lang/crates.io-index"
1198checksum = "7eff00be299a18769011411c9def0d827e8f2d7bf0c3dbf53633147a8867fd1f"
1199dependencies = [
1200 "no_std_io2",
1201]
1202
1203[[package]]
1204878name = "bitvec"
1205879version = "1.1.1"
1206880source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1214,15 +888,6 @@
1214888
1215889[[package]]
1216890name = "blake2"
1217version = "0.10.6"
1218source = "registry+https://github.com/rust-lang/crates.io-index"
1219checksum = "46502ad458c9a52b69d4d4d32775c788b7a1b85e8bc9d482d92250fc0e3f8efe"
1220dependencies = [
1221 "digest 0.10.7",
1222]
1223
1224[[package]]
1225name = "blake2"
1226891version = "0.11.0"
1227892source = "registry+https://github.com/rust-lang/crates.io-index"
1228893checksum = "5b5d4d889834ee8ecfc0f8426ad30faf7cdcb10f741a8e6d7224d95325479f6f"
@@ -1231,19 +896,6 @@
1231896]
1232897
1233898[[package]]
1234name = "blake3"
1235version = "1.8.7"
1236source = "registry+https://github.com/rust-lang/crates.io-index"
1237checksum = "6d9e454fc11f76977dc803893aff6304ed33d6a26efae8696573bea74baa27ae"
1238dependencies = [
1239 "arrayvec",
1240 "cc",
1241 "cfg-if",
1242 "constant_time_eq",
1243 "cpufeatures 0.3.0",
1244]
1245
1246[[package]]
1247899name = "block-buffer"
1248900version = "0.10.4"
1249901source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1306,36 +958,6 @@
1306958]
1307959
1308960[[package]]
1309name = "brotli"
1310version = "8.0.4"
1311source = "registry+https://github.com/rust-lang/crates.io-index"
1312checksum = "5cc91aac060a7a1e25823bdccbfb6af1875b88f17c6daac97894eed8207166b3"
1313dependencies = [
1314 "alloc-no-stdlib",
1315 "alloc-stdlib",
1316 "brotli-decompressor",
1317]
1318
1319[[package]]
1320name = "brotli-decompressor"
1321version = "5.0.3"
1322source = "registry+https://github.com/rust-lang/crates.io-index"
1323checksum = "3a32acac15fe1967bc3986b2a6347dffc965602354ea6f450ad07e8bfd253583"
1324dependencies = [
1325 "alloc-no-stdlib",
1326 "alloc-stdlib",
1327]
1328
1329[[package]]
1330name = "bs58"
1331version = "0.5.1"
1332source = "registry+https://github.com/rust-lang/crates.io-index"
1333checksum = "bf88ba1141d185c399bee5288d850d63b8369520c1eafc32a0430b5b6c287bf4"
1334dependencies = [
1335 "tinyvec",
1336]
1337
1338[[package]]
1339961name = "bstr"
1340962version = "1.13.1"
1341963source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1347,12 +969,6 @@
1347969]
1348970
1349971[[package]]
1350name = "built"
1351version = "0.8.1"
1352source = "registry+https://github.com/rust-lang/crates.io-index"
1353checksum = "5c0e531d93d39c34eef561e929e8a7f86d77a5af08aac4f6d6e39976c51858e9"
1354
1355[[package]]
1356972name = "bumpalo"
1357973version = "3.20.3"
1358974source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1364,20 +980,8 @@
1364980source = "registry+https://github.com/rust-lang/crates.io-index"
1365981checksum = "23cdc57ce23ac53c931e88a43d06d070a6fd142f2617be5855eb75efc9beb1c2"
1366982dependencies = [
1367 "bytecheck_derive 0.6.12",
1368 "ptr_meta 0.1.4",
1369 "simdutf8",
1370]
1371
1372[[package]]
1373name = "bytecheck"
1374version = "0.8.3"
1375source = "registry+https://github.com/rust-lang/crates.io-index"
1376checksum = "26333eeac754f0ad8a6bcd0eb0ac012156302e4e16b852b72ee399aea4f12c29"
1377dependencies = [
1378 "bytecheck_derive 0.8.3",
1379 "ptr_meta 0.3.2",
1380 "rancor",
983 "bytecheck_derive",
984 "ptr_meta",
1381985 "simdutf8",
1382986]
1383987
@@ -1393,17 +997,6 @@
1393997]
1394998
1395999[[package]]
1396name = "bytecheck_derive"
1397version = "0.8.3"
1398source = "registry+https://github.com/rust-lang/crates.io-index"
1399checksum = "46d07918caa9eeaaf06b7873925c53a61daac173539b4f7715090745e44e4e69"
1400dependencies = [
1401 "proc-macro2",
1402 "quote",
1403 "syn 3.0.3",
1404]
1405
1406[[package]]
14071000name = "bytemuck"
14081001version = "1.25.2"
14091002source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1416,12 +1009,6 @@
14161009checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
14171010
14181011[[package]]
1419name = "byteorder-lite"
1420version = "0.1.0"
1421source = "registry+https://github.com/rust-lang/crates.io-index"
1422checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495"
1423
1424[[package]]
14251012name = "bytes"
14261013version = "1.12.1"
14271014source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1458,15 +1045,6 @@
14581045]
14591046
14601047[[package]]
1461name = "castaway"
1462version = "0.2.4"
1463source = "registry+https://github.com/rust-lang/crates.io-index"
1464checksum = "dec551ab6e7578819132c713a93c022a05d60159dc86e7a7050223577484c55a"
1465dependencies = [
1466 "rustversion",
1467]
1468
1469[[package]]
14701048name = "cbc"
14711049version = "0.2.1"
14721050source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1488,15 +1066,6 @@
14881066]
14891067
14901068[[package]]
1491name = "cedarwood"
1492version = "0.4.6"
1493source = "registry+https://github.com/rust-lang/crates.io-index"
1494checksum = "6d910bedd62c24733263d0bed247460853c9d22e8956bd4cd964302095e04e90"
1495dependencies = [
1496 "smallvec",
1497]
1498
1499[[package]]
15001069name = "cfg-if"
15011070version = "1.0.4"
15021071source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1568,16 +1137,6 @@
15681137]
15691138
15701139[[package]]
1571name = "chrono-tz"
1572version = "0.10.4"
1573source = "registry+https://github.com/rust-lang/crates.io-index"
1574checksum = "a6139a8597ed92cf816dfb33f5dd6cf0bb93a6adc938f11039f371bc5bcd26c3"
1575dependencies = [
1576 "chrono",
1577 "phf 0.12.1",
1578]
1579
1580[[package]]
15811140name = "cipher"
15821141version = "0.4.4"
15831142source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1630,12 +1189,6 @@
16301189checksum = "d7ee2cfacbd29706479902b06d75ad8f1362900836aa32799eabc7e004bfd854"
16311190
16321191[[package]]
1633name = "color_quant"
1634version = "1.1.0"
1635source = "registry+https://github.com/rust-lang/crates.io-index"
1636checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
1637
1638[[package]]
16391192name = "combine"
16401193version = "4.6.7"
16411194source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1650,48 +1203,6 @@
16501203]
16511204
16521205[[package]]
1653name = "comfy-table"
1654version = "7.2.2"
1655source = "registry+https://github.com/rust-lang/crates.io-index"
1656checksum = "958c5d6ecf1f214b4c2bbbbf6ab9523a864bd136dcf71a7e8904799acfe1ad47"
1657dependencies = [
1658 "unicode-segmentation",
1659 "unicode-width",
1660]
1661
1662[[package]]
1663name = "compact_str"
1664version = "0.9.1"
1665source = "registry+https://github.com/rust-lang/crates.io-index"
1666checksum = "9dfdd1c2274d9aa354115b09dc9a901d6c5576818cdf70d14cae2bdb47df00ab"
1667dependencies = [
1668 "castaway",
1669 "cfg-if",
1670 "itoa",
1671 "rustversion",
1672 "ryu",
1673 "serde",
1674 "static_assertions",
1675]
1676
1677[[package]]
1678name = "compression-codecs"
1679version = "0.4.40"
1680source = "registry+https://github.com/rust-lang/crates.io-index"
1681checksum = "100590da849306918656ffbb22576bbdfc1382b50ad10d1d50ec177d3b205fb2"
1682dependencies = [
1683 "compression-core",
1684 "flate2",
1685 "memchr",
1686]
1687
1688[[package]]
1689name = "compression-core"
1690version = "0.4.33"
1691source = "registry+https://github.com/rust-lang/crates.io-index"
1692checksum = "6e8ccc4ea9f6acc32d102c0f6d471d11d913ad15f20c04de743374861fa1d414"
1693
1694[[package]]
16951206name = "concurrent-queue"
16961207version = "2.5.0"
16971208source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1714,19 +1225,6 @@
17141225]
17151226
17161227[[package]]
1717name = "console"
1718version = "0.15.11"
1719source = "registry+https://github.com/rust-lang/crates.io-index"
1720checksum = "054ccb5b10f9f2cbf51eb355ca1d05c2d279ce1804688d0db74b4733a5aeafd8"
1721dependencies = [
1722 "encode_unicode",
1723 "libc",
1724 "once_cell",
1725 "unicode-width",
1726 "windows-sys 0.59.0",
1727]
1728
1729[[package]]
17301228name = "const-oid"
17311229version = "0.9.6"
17321230source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1759,21 +1257,6 @@
17591257]
17601258
17611259[[package]]
1762name = "constant_time_eq"
1763version = "0.4.2"
1764source = "registry+https://github.com/rust-lang/crates.io-index"
1765checksum = "3d52eff69cd5e647efe296129160853a42795992097e8af39800e1060caeea9b"
1766
1767[[package]]
1768name = "convert_case"
1769version = "0.11.0"
1770source = "registry+https://github.com/rust-lang/crates.io-index"
1771checksum = "affbf0190ed2caf063e3def54ff444b449371d55c58e513a95ab98eca50adb49"
1772dependencies = [
1773 "unicode-segmentation",
1774]
1775
1776[[package]]
17771260name = "cookie"
17781261version = "0.18.2"
17791262source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1790,16 +1273,6 @@
17901273
17911274[[package]]
17921275name = "core-foundation"
1793version = "0.9.4"
1794source = "registry+https://github.com/rust-lang/crates.io-index"
1795checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
1796dependencies = [
1797 "core-foundation-sys",
1798 "libc",
1799]
1800
1801[[package]]
1802name = "core-foundation"
18031276version = "0.10.1"
18041277source = "registry+https://github.com/rust-lang/crates.io-index"
18051278checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6"
@@ -1898,16 +1371,6 @@
18981371]
18991372
19001373[[package]]
1901name = "crossbeam-deque"
1902version = "0.8.8"
1903source = "registry+https://github.com/rust-lang/crates.io-index"
1904checksum = "622f3fc73690be383c7214310406f28a90e6edeadc3cea882f9d71e495b9711a"
1905dependencies = [
1906 "crossbeam-epoch",
1907 "crossbeam-utils",
1908]
1909
1910[[package]]
19111374name = "crossbeam-epoch"
19121375version = "0.9.20"
19131376source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1926,16 +1389,6 @@
19261389]
19271390
19281391[[package]]
1929name = "crossbeam-skiplist"
1930version = "0.1.3"
1931source = "registry+https://github.com/rust-lang/crates.io-index"
1932checksum = "df29de440c58ca2cc6e587ec3d22347551a32435fbde9d2bff64e78a9ffa151b"
1933dependencies = [
1934 "crossbeam-epoch",
1935 "crossbeam-utils",
1936]
1937
1938[[package]]
19391392name = "crossbeam-utils"
19401393version = "0.8.22"
19411394source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -2009,27 +1462,6 @@
20091462]
20101463
20111464[[package]]
2012name = "csv"
2013version = "1.4.0"
2014source = "registry+https://github.com/rust-lang/crates.io-index"
2015checksum = "52cd9d68cf7efc6ddfaaee42e7288d3a99d613d4b50f76ce9827ae0c6e14f938"
2016dependencies = [
2017 "csv-core",
2018 "itoa",
2019 "ryu",
2020 "serde_core",
2021]
2022
2023[[package]]
2024name = "csv-core"
2025version = "0.1.13"
2026source = "registry+https://github.com/rust-lang/crates.io-index"
2027checksum = "704a3c26996a80471189265814dbc2c257598b96b8a7feae2d31ace646bb9782"
2028dependencies = [
2029 "memchr",
2030]
2031
2032[[package]]
20331465name = "ctr"
20341466version = "0.9.2"
20351467source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -2058,23 +1490,6 @@
20581490]
20591491
20601492[[package]]
2061name = "cubesandbox"
2062version = "0.1.0"
2063source = "git+https://gitea.gitdata.me/GitDataAi/sanbox-client.git?rev=91ba6f56ac#91ba6f56acd3ee884326aeb4fdd77cc8881c7a7d"
2064dependencies = [
2065 "base64 0.23.1",
2066 "bytes",
2067 "chrono",
2068 "futures",
2069 "reqwest 0.13.4",
2070 "serde",
2071 "serde_json",
2072 "thiserror 2.0.20",
2073 "tokio",
2074 "url 2.5.8",
2075]
2076
2077[[package]]
20781493name = "cuckoofilter"
20791494version = "0.5.0"
20801495source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -2087,21 +1502,6 @@
20871502
20881503[[package]]
20891504name = "curve25519-dalek"
2090version = "4.1.3"
2091source = "registry+https://github.com/rust-lang/crates.io-index"
2092checksum = "97fb8b7c4503de7d6ae7b42ab72a5a59857b4c937ec27a3d4539dba95b5ab2be"
2093dependencies = [
2094 "cfg-if",
2095 "cpufeatures 0.2.17",
2096 "curve25519-dalek-derive",
2097 "digest 0.10.7",
2098 "fiat-crypto 0.2.9",
2099 "rustc_version",
2100 "subtle",
2101]
2102
2103[[package]]
2104name = "curve25519-dalek"
21051505version = "5.0.0"
21061506source = "registry+https://github.com/rust-lang/crates.io-index"
21071507checksum = "b5eed333089e2e1c1ac8c6c0398e5e2497b4c9926ca6d0365ed1e099afa5bc23"
@@ -2110,7 +1510,7 @@
21101510 "cpufeatures 0.3.0",
21111511 "curve25519-dalek-derive",
21121512 "digest 0.11.3",
2113 "fiat-crypto 0.3.0",
1513 "fiat-crypto",
21141514 "rand_core 0.10.1",
21151515 "rustc_version",
21161516 "subtle",
@@ -2129,12 +1529,6 @@
21291529]
21301530
21311531[[package]]
2132name = "daachorse"
2133version = "2.1.1"
2134source = "registry+https://github.com/rust-lang/crates.io-index"
2135checksum = "db756b5eb7d81d31f31f660f4132f8cf5698de52fca144c143d0ae0cbb5f2e06"
2136
2137[[package]]
21381532name = "darling"
21391533version = "0.20.11"
21401534source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -2155,16 +1549,6 @@
21551549]
21561550
21571551[[package]]
2158name = "darling"
2159version = "0.24.1"
2160source = "registry+https://github.com/rust-lang/crates.io-index"
2161checksum = "ed17f5901b6630b993ca003def43f2f8ef4014fc13b047b57aad617ff32bc2ec"
2162dependencies = [
2163 "darling_core 0.24.1",
2164 "darling_macro 0.24.1",
2165]
2166
2167[[package]]
21681552name = "darling_core"
21691553version = "0.20.11"
21701554source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -2192,19 +1576,6 @@
21921576]
21931577
21941578[[package]]
2195name = "darling_core"
2196version = "0.24.1"
2197source = "registry+https://github.com/rust-lang/crates.io-index"
2198checksum = "6837e2cf7485aaae18f86181d2f0e9a7ed297a025e220aeabf63fdebd3a2ddff"
2199dependencies = [
2200 "ident_case",
2201 "proc-macro2",
2202 "quote",
2203 "strsim",
2204 "syn 3.0.3",
2205]
2206
2207[[package]]
22081579name = "darling_macro"
22091580version = "0.20.11"
22101581source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -2227,26 +1598,6 @@
22271598]
22281599
22291600[[package]]
2230name = "darling_macro"
2231version = "0.24.1"
2232source = "registry+https://github.com/rust-lang/crates.io-index"
2233checksum = "2ac7135c3ef02b2f7833bbeb1be5ba7f966dcde8a87c6b87f65a778d71a02785"
2234dependencies = [
2235 "darling_core 0.24.1",
2236 "quote",
2237 "syn 3.0.3",
2238]
2239
2240[[package]]
2241name = "dary_heap"
2242version = "0.3.9"
2243source = "registry+https://github.com/rust-lang/crates.io-index"
2244checksum = "8b1e3a325bc115f096c8b77bbf027a7c2592230e70be2d985be950d3d5e60ebe"
2245dependencies = [
2246 "serde",
2247]
2248
2249[[package]]
22501601name = "dashmap"
22511602version = "6.2.1"
22521603source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -2267,1823 +1618,952 @@
22671618checksum = "4583a4551df46e2792f82ceeac45e850d2e2d5debba0b91f102385cda5b11f06"
22681619
22691620[[package]]
2270name = "datafusion"
2271version = "53.1.0"
1621name = "defmt"
1622version = "1.1.1"
22721623source = "registry+https://github.com/rust-lang/crates.io-index"
2273checksum = "93db0e623840612f7f2cd757f7e8a8922064192363732c88692e0870016e141b"
1624checksum = "e2953bfe4f93bbd20cc71198842756f77d161884c99ebbabc41d80231ded88d1"
22741625dependencies = [
2275 "arrow",
2276 "arrow-schema",
2277 "async-trait",
2278 "bytes",
2279 "chrono",
2280 "datafusion-catalog",
2281 "datafusion-catalog-listing",
2282 "datafusion-common",
2283 "datafusion-common-runtime",
2284 "datafusion-datasource",
2285 "datafusion-datasource-arrow",
2286 "datafusion-datasource-csv",
2287 "datafusion-datasource-json",
2288 "datafusion-execution",
2289 "datafusion-expr",
2290 "datafusion-expr-common",
2291 "datafusion-functions",
2292 "datafusion-functions-aggregate",
2293 "datafusion-functions-nested",
2294 "datafusion-functions-table",
2295 "datafusion-functions-window",
2296 "datafusion-optimizer",
2297 "datafusion-physical-expr",
2298 "datafusion-physical-expr-adapter",
2299 "datafusion-physical-expr-common",
2300 "datafusion-physical-optimizer",
2301 "datafusion-physical-plan",
2302 "datafusion-session",
2303 "datafusion-sql",
2304 "futures",
2305 "itertools 0.14.0",
2306 "log 0.4.33",
2307 "object_store",
2308 "parking_lot",
2309 "rand 0.9.5",
2310 "regex",
2311 "sqlparser",
2312 "tempfile",
2313 "tokio",
2314 "url 2.5.8",
2315 "uuid",
1626 "bitflags 1.3.2",
1627 "defmt-macros",
23161628]
23171629
23181630[[package]]
2319name = "datafusion-catalog"
2320version = "53.1.0"
1631name = "defmt-macros"
1632version = "1.1.1"
23211633source = "registry+https://github.com/rust-lang/crates.io-index"
2322checksum = "37cefde60b26a7f4ff61e9d2ff2833322f91df2b568d7238afe67bde5bdffb66"
1634checksum = "bad9c72e7ca2137e0dc3813245a0d282fd6daad32fd800af018306a9169b5fe8"
23231635dependencies = [
2324 "arrow",
2325 "async-trait",
2326 "dashmap",
2327 "datafusion-common",
2328 "datafusion-common-runtime",
2329 "datafusion-datasource",
2330 "datafusion-execution",
2331 "datafusion-expr",
2332 "datafusion-physical-expr",
2333 "datafusion-physical-plan",
2334 "datafusion-session",
2335 "futures",
2336 "itertools 0.14.0",
2337 "log 0.4.33",
2338 "object_store",
2339 "parking_lot",
2340 "tokio",
1636 "defmt-parser",
1637 "proc-macro2",
1638 "quote",
1639 "syn 2.0.119",
23411640]
23421641
23431642[[package]]
2344name = "datafusion-catalog-listing"
2345version = "53.1.0"
1643name = "defmt-parser"
1644version = "1.0.0"
23461645source = "registry+https://github.com/rust-lang/crates.io-index"
2347checksum = "17e112307715d6a7a331111a4c2330ff54bc237183511c319e3708a4cff431fb"
1646checksum = "10d60334b3b2e7c9d91ef8150abfb6fa4c1c39ebbcf4a81c2e346aad939fee3e"
23481647dependencies = [
2349 "arrow",
2350 "async-trait",
2351 "datafusion-catalog",
2352 "datafusion-common",
2353 "datafusion-datasource",
2354 "datafusion-execution",
2355 "datafusion-expr",
2356 "datafusion-physical-expr",
2357 "datafusion-physical-expr-adapter",
2358 "datafusion-physical-expr-common",
2359 "datafusion-physical-plan",
2360 "futures",
2361 "itertools 0.14.0",
2362 "log 0.4.33",
2363 "object_store",
1648 "thiserror 2.0.20",
23641649]
23651650
23661651[[package]]
2367name = "datafusion-common"
2368version = "53.1.0"
1652name = "delegate"
1653version = "0.13.5"
23691654source = "registry+https://github.com/rust-lang/crates.io-index"
2370checksum = "d72a11ca44a95e1081870d3abb80c717496e8a7acb467a1d3e932bb636af5cc2"
1655checksum = "780eb241654bf097afb00fc5f054a09b687dad862e485fdcf8399bb056565370"
23711656dependencies = [
2372 "ahash 0.8.12",
2373 "arrow",
2374 "arrow-ipc",
2375 "chrono",
2376 "half",
2377 "hashbrown 0.16.1",
2378 "indexmap 2.14.0",
2379 "itertools 0.14.0",
2380 "libc",
2381 "log 0.4.33",
2382 "object_store",
2383 "paste",
2384 "sqlparser",
2385 "tokio",
2386 "web-time",
1657 "proc-macro2",
1658 "quote",
1659 "syn 2.0.119",
23871660]
23881661
23891662[[package]]
2390name = "datafusion-common-runtime"
2391version = "53.1.0"
1663name = "der"
1664version = "0.7.10"
23921665source = "registry+https://github.com/rust-lang/crates.io-index"
2393checksum = "89f4afaed29670ec4fd6053643adc749fe3f4bc9d1ce1b8c5679b22c67d12def"
1666checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb"
23941667dependencies = [
2395 "futures",
2396 "log 0.4.33",
2397 "tokio",
1668 "const-oid 0.9.6",
1669 "zeroize",
23981670]
23991671
24001672[[package]]
2401name = "datafusion-datasource"
2402version = "53.1.0"
1673name = "der"
1674version = "0.8.1"
24031675source = "registry+https://github.com/rust-lang/crates.io-index"
2404checksum = "e9fb386e1691355355a96419978a0022b7947b44d4a24a6ea99f00b6b485cbb6"
1676checksum = "a69dedd701da44b0536442edf09c81a64b0ab97a7a4a5e3d1971f00027cbc63d"
24051677dependencies = [
2406 "arrow",
2407 "async-trait",
2408 "bytes",
2409 "chrono",
2410 "datafusion-common",
2411 "datafusion-common-runtime",
2412 "datafusion-execution",
2413 "datafusion-expr",
2414 "datafusion-physical-expr",
2415 "datafusion-physical-expr-adapter",
2416 "datafusion-physical-expr-common",
2417 "datafusion-physical-plan",
2418 "datafusion-session",
2419 "futures",
2420 "glob",
2421 "itertools 0.14.0",
2422 "log 0.4.33",
2423 "object_store",
2424 "rand 0.9.5",
2425 "tokio",
2426 "url 2.5.8",
1678 "const-oid 0.10.2",
1679 "pem-rfc7468 1.0.0",
1680 "zeroize",
24271681]
24281682
24291683[[package]]
2430name = "datafusion-datasource-arrow"
2431version = "53.1.0"
1684name = "deranged"
1685version = "0.5.8"
24321686source = "registry+https://github.com/rust-lang/crates.io-index"
2433checksum = "ffa6c52cfed0734c5f93754d1c0175f558175248bf686c944fb05c373e5fc096"
1687checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"
24341688dependencies = [
2435 "arrow",
2436 "arrow-ipc",
2437 "async-trait",
2438 "bytes",
2439 "datafusion-common",
2440 "datafusion-common-runtime",
2441 "datafusion-datasource",
2442 "datafusion-execution",
2443 "datafusion-expr",
2444 "datafusion-physical-expr-common",
2445 "datafusion-physical-plan",
2446 "datafusion-session",
2447 "futures",
2448 "itertools 0.14.0",
2449 "object_store",
2450 "tokio",
1689 "serde_core",
24511690]
24521691
24531692[[package]]
2454name = "datafusion-datasource-csv"
2455version = "53.1.0"
1693name = "derive-where"
1694version = "1.6.1"
24561695source = "registry+https://github.com/rust-lang/crates.io-index"
2457checksum = "503f29e0582c1fc189578d665ff57d9300da1f80c282777d7eb67bb79fb8cdca"
1696checksum = "d08b3a0bcc0d079199cd476b2cae8435016ec11d1c0986c6901c5ac223041534"
24581697dependencies = [
2459 "arrow",
2460 "async-trait",
2461 "bytes",
2462 "datafusion-common",
2463 "datafusion-common-runtime",
2464 "datafusion-datasource",
2465 "datafusion-execution",
2466 "datafusion-expr",
2467 "datafusion-physical-expr-common",
2468 "datafusion-physical-plan",
2469 "datafusion-session",
2470 "futures",
2471 "object_store",
2472 "regex",
2473 "tokio",
1698 "proc-macro2",
1699 "quote",
1700 "syn 2.0.119",
24741701]
24751702
24761703[[package]]
2477name = "datafusion-datasource-json"
2478version = "53.1.0"
1704name = "derive_arbitrary"
1705version = "1.4.2"
24791706source = "registry+https://github.com/rust-lang/crates.io-index"
2480checksum = "e33804749abc8d0c8cb7473228483cb8070e524c6f6086ee1b85a64debe2b3d2"
1707checksum = "1e567bd82dcff979e4b03460c307b3cdc9e96fde3d73bed1496d2bc75d9dd62a"
24811708dependencies = [
2482 "arrow",
2483 "async-trait",
2484 "bytes",
2485 "datafusion-common",
2486 "datafusion-common-runtime",
2487 "datafusion-datasource",
2488 "datafusion-execution",
2489 "datafusion-expr",
2490 "datafusion-physical-expr-common",
2491 "datafusion-physical-plan",
2492 "datafusion-session",
2493 "futures",
2494 "object_store",
2495 "serde_json",
2496 "tokio",
2497 "tokio-stream",
1709 "proc-macro2",
1710 "quote",
1711 "syn 2.0.119",
24981712]
24991713
25001714[[package]]
2501name = "datafusion-doc"
2502version = "53.1.0"
1715name = "derive_builder"
1716version = "0.20.2"
25031717source = "registry+https://github.com/rust-lang/crates.io-index"
2504checksum = "8de6ac0df1662b9148ad3c987978b32cbec7c772f199b1d53520c8fa764a87ee"
2505
2506[[package]]
2507name = "datafusion-execution"
2508version = "53.1.0"
2509source = "registry+https://github.com/rust-lang/crates.io-index"
2510checksum = "c03c7fbdaefcca4ef6ffe425a5fc2325763bfb426599bb0bf4536466efabe709"
1718checksum = "507dfb09ea8b7fa618fcf76e953f4f5e192547945816d5358edffe39f6f94947"
25111719dependencies = [
2512 "arrow",
2513 "arrow-buffer",
2514 "async-trait",
2515 "chrono",
2516 "dashmap",
2517 "datafusion-common",
2518 "datafusion-expr",
2519 "datafusion-physical-expr-common",
2520 "futures",
2521 "log 0.4.33",
2522 "object_store",
2523 "parking_lot",
2524 "rand 0.9.5",
2525 "tempfile",
2526 "url 2.5.8",
1720 "derive_builder_macro",
25271721]
25281722
25291723[[package]]
2530name = "datafusion-expr"
2531version = "53.1.0"
1724name = "derive_builder_core"
1725version = "0.20.2"
25321726source = "registry+https://github.com/rust-lang/crates.io-index"
2533checksum = "574b9b6977fedbd2a611cbff12e5caf90f31640ad9dc5870f152836d94bad0dd"
1727checksum = "2d5bcf7b024d6835cfb3d473887cd966994907effbe9227e8c8219824d06c4e8"
25341728dependencies = [
2535 "arrow",
2536 "async-trait",
2537 "chrono",
2538 "datafusion-common",
2539 "datafusion-doc",
2540 "datafusion-expr-common",
2541 "datafusion-functions-aggregate-common",
2542 "datafusion-functions-window-common",
2543 "datafusion-physical-expr-common",
2544 "indexmap 2.14.0",
2545 "itertools 0.14.0",
2546 "paste",
2547 "serde_json",
2548 "sqlparser",
1729 "darling 0.20.11",
1730 "proc-macro2",
1731 "quote",
1732 "syn 2.0.119",
25491733]
25501734
25511735[[package]]
2552name = "datafusion-expr-common"
2553version = "53.1.0"
1736name = "derive_builder_macro"
1737version = "0.20.2"
25541738source = "registry+https://github.com/rust-lang/crates.io-index"
2555checksum = "7d7c3adf3db8bf61e92eb90cb659c8e8b734593a8f7c8e12a843c7ddba24b87e"
1739checksum = "ab63b0e2bf4d5928aff72e83a7dace85d7bba5fe12dcc3c5a572d78caffd3f3c"
25561740dependencies = [
2557 "arrow",
2558 "datafusion-common",
2559 "indexmap 2.14.0",
2560 "itertools 0.14.0",
2561 "paste",
1741 "derive_builder_core",
1742 "syn 2.0.119",
25621743]
25631744
25641745[[package]]
2565name = "datafusion-functions"
2566version = "53.1.0"
1746name = "derive_more"
1747version = "2.1.1"
25671748source = "registry+https://github.com/rust-lang/crates.io-index"
2568checksum = "f28aa4e10384e782774b10e72aca4d93ef7b31aa653095d9d4536b0a3dbc51b6"
1749checksum = "d751e9e49156b02b44f9c1815bcb94b984cdcc4396ecc32521c739452808b134"
25691750dependencies = [
2570 "arrow",
2571 "arrow-buffer",
2572 "base64 0.22.1",
2573 "blake2 0.10.6",
2574 "blake3",
2575 "chrono",
2576 "chrono-tz",
2577 "datafusion-common",
2578 "datafusion-doc",
2579 "datafusion-execution",
2580 "datafusion-expr",
2581 "datafusion-expr-common",
2582 "datafusion-macros",
2583 "hex",
2584 "itertools 0.14.0",
2585 "log 0.4.33",
2586 "md-5 0.10.6",
2587 "memchr",
2588 "num-traits",
2589 "rand 0.9.5",
2590 "regex",
2591 "sha2 0.10.9",
2592 "unicode-segmentation",
2593 "uuid",
1751 "derive_more-impl",
25941752]
25951753
25961754[[package]]
2597name = "datafusion-functions-aggregate"
2598version = "53.1.0"
1755name = "derive_more-impl"
1756version = "2.1.1"
25991757source = "registry+https://github.com/rust-lang/crates.io-index"
2600checksum = "00aa6217e56098ba84e0a338176fe52f0a84cca398021512c6c8c5eff806d0ad"
1758checksum = "799a97264921d8623a957f6c3b9011f3b5492f557bbb7a5a19b7fa6d06ba8dcb"
26011759dependencies = [
2602 "ahash 0.8.12",
2603 "arrow",
2604 "datafusion-common",
2605 "datafusion-doc",
2606 "datafusion-execution",
2607 "datafusion-expr",
2608 "datafusion-functions-aggregate-common",
2609 "datafusion-macros",
2610 "datafusion-physical-expr",
2611 "datafusion-physical-expr-common",
2612 "half",
2613 "log 0.4.33",
2614 "num-traits",
2615 "paste",
1760 "proc-macro2",
1761 "quote",
1762 "rustc_version",
1763 "syn 2.0.119",
1764 "unicode-xid",
26161765]
26171766
26181767[[package]]
2619name = "datafusion-functions-aggregate-common"
2620version = "53.1.0"
1768name = "des"
1769version = "0.9.0"
26211770source = "registry+https://github.com/rust-lang/crates.io-index"
2622checksum = "b511250349407db7c43832ab2de63f5557b19a20dfd236b39ca2c04468b50d47"
1771checksum = "916a94e407b54f9034d71dd748234cd1e516ced6284009906ae246f177eafe5a"
26231772dependencies = [
2624 "ahash 0.8.12",
2625 "arrow",
2626 "datafusion-common",
2627 "datafusion-expr-common",
2628 "datafusion-physical-expr-common",
1773 "cipher 0.5.2",
26291774]
26301775
26311776[[package]]
2632name = "datafusion-functions-nested"
2633version = "53.1.0"
1777name = "digest"
1778version = "0.10.7"
26341779source = "registry+https://github.com/rust-lang/crates.io-index"
2635checksum = "ef13a858e20d50f0a9bb5e96e7ac82b4e7597f247515bccca4fdd2992df0212a"
1780checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
26361781dependencies = [
2637 "arrow",
2638 "arrow-ord",
2639 "datafusion-common",
2640 "datafusion-doc",
2641 "datafusion-execution",
2642 "datafusion-expr",
2643 "datafusion-expr-common",
2644 "datafusion-functions",
2645 "datafusion-functions-aggregate",
2646 "datafusion-functions-aggregate-common",
2647 "datafusion-macros",
2648 "datafusion-physical-expr-common",
2649 "hashbrown 0.16.1",
2650 "itertools 0.14.0",
2651 "itoa",
2652 "log 0.4.33",
2653 "paste",
1782 "block-buffer 0.10.4",
1783 "const-oid 0.9.6",
1784 "crypto-common 0.1.6",
1785 "subtle",
26541786]
26551787
26561788[[package]]
2657name = "datafusion-functions-table"
2658version = "53.1.0"
1789name = "digest"
1790version = "0.11.3"
26591791source = "registry+https://github.com/rust-lang/crates.io-index"
2660checksum = "72b40d3f5bbb3905f9ccb1ce9485a9595c77b69758a7c24d3ba79e334ff51e7e"
1792checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2"
26611793dependencies = [
2662 "arrow",
2663 "async-trait",
2664 "datafusion-catalog",
2665 "datafusion-common",
2666 "datafusion-expr",
2667 "datafusion-physical-plan",
2668 "parking_lot",
2669 "paste",
1794 "block-buffer 0.12.1",
1795 "const-oid 0.10.2",
1796 "crypto-common 0.2.2",
1797 "ctutils",
26701798]
26711799
26721800[[package]]
2673name = "datafusion-functions-window"
2674version = "53.1.0"
1801name = "dirs"
1802version = "5.0.1"
26751803source = "registry+https://github.com/rust-lang/crates.io-index"
2676checksum = "d4e88ec9d57c9b685d02f58bfee7be62d72610430ddcedb82a08e5d9925dbfb6"
1804checksum = "44c45a9d03d6676652bcb5e724c7e988de1acad23a711b5217ab9cbecbec2225"
26771805dependencies = [
2678 "arrow",
2679 "datafusion-common",
2680 "datafusion-doc",
2681 "datafusion-expr",
2682 "datafusion-functions-window-common",
2683 "datafusion-macros",
2684 "datafusion-physical-expr",
2685 "datafusion-physical-expr-common",
2686 "log 0.4.33",
2687 "paste",
1806 "dirs-sys",
26881807]
26891808
26901809[[package]]
2691name = "datafusion-functions-window-common"
2692version = "53.1.0"
1810name = "dirs-sys"
1811version = "0.4.1"
26931812source = "registry+https://github.com/rust-lang/crates.io-index"
2694checksum = "8307bb93519b1a91913723a1130cfafeee3f72200d870d88e91a6fc5470ede5c"
1813checksum = "520f05a5cbd335fae5a99ff7a6ab8627577660ee5cfd6a94a6a929b52ff0321c"
26951814dependencies = [
2696 "datafusion-common",
2697 "datafusion-physical-expr-common",
1815 "libc",
1816 "option-ext",
1817 "redox_users",
1818 "windows-sys 0.48.0",
26981819]
26991820
27001821[[package]]
2701name = "datafusion-macros"
2702version = "53.1.0"
1822name = "displaydoc"
1823version = "0.2.7"
27031824source = "registry+https://github.com/rust-lang/crates.io-index"
2704checksum = "2e367e6a71051d0ebdd29b2f85d12059b38b1d1f172c6906e80016da662226bd"
1825checksum = "c6232dd377dcc64799954cbd3a9bb882e9cdc1308ccd87b1c098f1fb2eaf82a8"
27051826dependencies = [
2706 "datafusion-doc",
1827 "proc-macro2",
27071828 "quote",
2708 "syn 2.0.119",
1829 "syn 3.0.3",
27091830]
27101831
27111832[[package]]
2712name = "datafusion-optimizer"
2713version = "53.1.0"
1833name = "dlv-list"
1834version = "0.3.0"
27141835source = "registry+https://github.com/rust-lang/crates.io-index"
2715checksum = "e929015451a67f77d9d8b727b2bf3a40c4445fdef6cdc53281d7d97c76888ace"
2716dependencies = [
2717 "arrow",
2718 "chrono",
2719 "datafusion-common",
2720 "datafusion-expr",
2721 "datafusion-expr-common",
2722 "datafusion-physical-expr",
2723 "indexmap 2.14.0",
2724 "itertools 0.14.0",
2725 "log 0.4.33",
2726 "regex",
2727 "regex-syntax",
2728]
1836checksum = "0688c2a7f92e427f44895cd63841bff7b29f8d7a1648b9e7e07a4a365b2e1257"
27291837
27301838[[package]]
2731name = "datafusion-physical-expr"
2732version = "53.1.0"
1839name = "dotenvy"
1840version = "0.15.7"
27331841source = "registry+https://github.com/rust-lang/crates.io-index"
2734checksum = "4b1e68aba7a4b350401cfdf25a3d6f989ad898a7410164afe9ca52080244cb59"
2735dependencies = [
2736 "ahash 0.8.12",
2737 "arrow",
2738 "datafusion-common",
2739 "datafusion-expr",
2740 "datafusion-expr-common",
2741 "datafusion-functions-aggregate-common",
2742 "datafusion-physical-expr-common",
2743 "half",
2744 "hashbrown 0.16.1",
2745 "indexmap 2.14.0",
2746 "itertools 0.14.0",
2747 "parking_lot",
2748 "paste",
2749 "petgraph",
2750 "tokio",
2751]
1842checksum = "1aaf95b3e5c8f23aa320147307562d361db0ae0d51242340f558153b4eb2439b"
27521843
27531844[[package]]
2754name = "datafusion-physical-expr-adapter"
2755version = "53.1.0"
1845name = "dunce"
1846version = "1.0.5"
27561847source = "registry+https://github.com/rust-lang/crates.io-index"
2757checksum = "ea22315f33cf2e0adc104e8ec42e285f6ed93998d565c65e82fec6a9ee9f9db4"
2758dependencies = [
2759 "arrow",
2760 "datafusion-common",
2761 "datafusion-expr",
2762 "datafusion-functions",
2763 "datafusion-physical-expr",
2764 "datafusion-physical-expr-common",
2765 "itertools 0.14.0",
2766]
1848checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813"
27671849
27681850[[package]]
2769name = "datafusion-physical-expr-common"
2770version = "53.1.0"
1851name = "ecdsa"
1852version = "0.16.9"
27711853source = "registry+https://github.com/rust-lang/crates.io-index"
2772checksum = "b04b45ea8ad3ac2d78f2ea2a76053e06591c9629c7a603eda16c10649ecf4362"
1854checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca"
27731855dependencies = [
2774 "ahash 0.8.12",
2775 "arrow",
2776 "chrono",
2777 "datafusion-common",
2778 "datafusion-expr-common",
2779 "hashbrown 0.16.1",
2780 "indexmap 2.14.0",
2781 "itertools 0.14.0",
2782 "parking_lot",
1856 "der 0.7.10",
1857 "digest 0.10.7",
1858 "elliptic-curve 0.13.8",
1859 "rfc6979 0.4.0",
1860 "signature 2.2.0",
1861 "spki 0.7.3",
27831862]
27841863
27851864[[package]]
2786name = "datafusion-physical-optimizer"
2787version = "53.1.0"
1865name = "ecdsa"
1866version = "0.17.0"
27881867source = "registry+https://github.com/rust-lang/crates.io-index"
2789checksum = "7cb13397809a425918f608dfe8653f332015a3e330004ab191b4404187238b95"
2790dependencies = [
2791 "arrow",
2792 "datafusion-common",
2793 "datafusion-execution",
2794 "datafusion-expr",
2795 "datafusion-expr-common",
2796 "datafusion-physical-expr",
2797 "datafusion-physical-expr-common",
2798 "datafusion-physical-plan",
2799 "datafusion-pruning",
2800 "itertools 0.14.0",
2801]
2802
2803[[package]]
2804name = "datafusion-physical-plan"
2805version = "53.1.0"
2806source = "registry+https://github.com/rust-lang/crates.io-index"
2807checksum = "5edc023675791af9d5fb4cc4c24abf5f7bd3bd4dcf9e5bd90ea1eff6976dcc79"
1868checksum = "c0681a4fc24c767085329728d8dfba959af91228aa4610cca4f8ce317ba46ae0"
28081869dependencies = [
2809 "ahash 0.8.12",
2810 "arrow",
2811 "arrow-ord",
2812 "arrow-schema",
2813 "async-trait",
2814 "datafusion-common",
2815 "datafusion-common-runtime",
2816 "datafusion-execution",
2817 "datafusion-expr",
2818 "datafusion-functions",
2819 "datafusion-functions-aggregate-common",
2820 "datafusion-functions-window-common",
2821 "datafusion-physical-expr",
2822 "datafusion-physical-expr-common",
2823 "futures",
2824 "half",
2825 "hashbrown 0.16.1",
2826 "indexmap 2.14.0",
2827 "itertools 0.14.0",
2828 "log 0.4.33",
2829 "num-traits",
2830 "parking_lot",
2831 "pin-project-lite",
2832 "tokio",
1870 "der 0.8.1",
1871 "digest 0.11.3",
1872 "elliptic-curve 0.14.1",
1873 "rfc6979 0.6.0",
1874 "signature 3.0.0",
1875 "spki 0.8.0",
1876 "zeroize",
28331877]
28341878
28351879[[package]]
2836name = "datafusion-pruning"
2837version = "53.1.0"
1880name = "ed25519"
1881version = "3.0.0"
28381882source = "registry+https://github.com/rust-lang/crates.io-index"
2839checksum = "ac8c76860e355616555081cab5968cec1af7a80701ff374510860bcd567e365a"
1883checksum = "29fcf32e6c73d1079f83ab4d782de2d81620346a5f38c6237a86a22f8368980a"
28401884dependencies = [
2841 "arrow",
2842 "datafusion-common",
2843 "datafusion-datasource",
2844 "datafusion-expr-common",
2845 "datafusion-physical-expr",
2846 "datafusion-physical-expr-common",
2847 "datafusion-physical-plan",
2848 "itertools 0.14.0",
2849 "log 0.4.33",
1885 "pkcs8 0.11.0",
1886 "signature 3.0.0",
28501887]
28511888
28521889[[package]]
2853name = "datafusion-session"
2854version = "53.1.0"
1890name = "ed25519-dalek"
1891version = "3.0.0"
28551892source = "registry+https://github.com/rust-lang/crates.io-index"
2856checksum = "5412111aa48e2424ba926112e192f7a6b7e4ccb450145d25ce5ede9f19dc491e"
1893checksum = "6ebaa1a2bf1290ab3bfe5a7b771d050ebffab2711c19a81691c683a5144a25de"
28571894dependencies = [
2858 "async-trait",
2859 "datafusion-common",
2860 "datafusion-execution",
2861 "datafusion-expr",
2862 "datafusion-physical-plan",
2863 "parking_lot",
1895 "curve25519-dalek",
1896 "ed25519",
1897 "rand_core 0.10.1",
1898 "serde",
1899 "sha2 0.11.0",
1900 "signature 3.0.0",
1901 "subtle",
1902 "zeroize",
28641903]
28651904
28661905[[package]]
2867name = "datafusion-sql"
2868version = "53.1.0"
1906name = "either"
1907version = "1.17.0"
28691908source = "registry+https://github.com/rust-lang/crates.io-index"
2870checksum = "fa0d133ddf8b9b3b872acac900157f783e7b879fe9a6bccf389abebbfac45ec1"
1909checksum = "9e5e8f6c15a24b9a3ee5efec809ccd006d3b30e8b3bb63c39af737c7f87daa1d"
28711910dependencies = [
2872 "arrow",
2873 "bigdecimal",
2874 "chrono",
2875 "datafusion-common",
2876 "datafusion-expr",
2877 "datafusion-functions-nested",
2878 "indexmap 2.14.0",
2879 "log 0.4.33",
2880 "regex",
2881 "sqlparser",
1911 "serde",
28821912]
28831913
28841914[[package]]
2885name = "deepsize"
2886version = "0.2.0"
1915name = "elliptic-curve"
1916version = "0.13.8"
28871917source = "registry+https://github.com/rust-lang/crates.io-index"
2888checksum = "1cdb987ec36f6bf7bfbea3f928b75590b736fc42af8e54d97592481351b2b96c"
1918checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47"
28891919dependencies = [
2890 "deepsize_derive",
1920 "base16ct 0.2.0",
1921 "crypto-bigint 0.5.5",
1922 "digest 0.10.7",
1923 "ff 0.13.1",
1924 "generic-array 0.14.9",
1925 "group 0.13.0",
1926 "pkcs8 0.10.2",
1927 "rand_core 0.6.4",
1928 "sec1 0.7.3",
1929 "subtle",
1930 "zeroize",
28911931]
28921932
28931933[[package]]
2894name = "deepsize_derive"
2895version = "0.1.2"
1934name = "elliptic-curve"
1935version = "0.14.1"
28961936source = "registry+https://github.com/rust-lang/crates.io-index"
2897checksum = "990101d41f3bc8c1a45641024377ee284ecc338e5ecf3ea0f0e236d897c72796"
1937checksum = "9d65aa39b3a5c1c9c1b745c9a019234bb7a21b77abcb4f4d266d706e2d577d65"
28981938dependencies = [
2899 "proc-macro2",
2900 "quote",
2901 "syn 1.0.109",
1939 "base16ct 1.0.0",
1940 "crypto-bigint 0.7.5",
1941 "crypto-common 0.2.2",
1942 "digest 0.11.3",
1943 "ff 0.14.0",
1944 "group 0.14.0",
1945 "hkdf",
1946 "hybrid-array",
1947 "pem-rfc7468 1.0.0",
1948 "pkcs8 0.11.0",
1949 "rand_core 0.10.1",
1950 "sec1 0.8.1",
1951 "subtle",
1952 "zeroize",
29021953]
29031954
29041955[[package]]
2905name = "defmt"
2906version = "1.1.1"
2907source = "registry+https://github.com/rust-lang/crates.io-index"
2908checksum = "e2953bfe4f93bbd20cc71198842756f77d161884c99ebbabc41d80231ded88d1"
1956name = "email"
1957version = "1.0.0"
29091958dependencies = [
2910 "bitflags 1.3.2",
2911 "defmt-macros",
1959 "async-trait",
1960 "base64 0.23.1",
1961 "bytes",
1962 "config",
1963 "futures",
1964 "lettre",
1965 "maud",
1966 "redis",
1967 "serde",
1968 "serde_json",
1969 "time 0.3.55",
1970 "tokio",
1971 "tokio-util",
1972 "tracing",
1973 "uuid",
29121974]
29131975
29141976[[package]]
2915name = "defmt-macros"
2916version = "1.1.1"
1977name = "email-encoding"
1978version = "0.4.2"
29171979source = "registry+https://github.com/rust-lang/crates.io-index"
2918checksum = "bad9c72e7ca2137e0dc3813245a0d282fd6daad32fd800af018306a9169b5fe8"
1980checksum = "420b9da095f052ea597503e39073b5b3c522f7db933fbac202d91d24492693fd"
29191981dependencies = [
2920 "defmt-parser",
2921 "proc-macro2",
2922 "quote",
2923 "syn 2.0.119",
1982 "base64 0.23.1",
1983 "memchr",
29241984]
29251985
29261986[[package]]
2927name = "defmt-parser"
2928version = "1.0.0"
1987name = "email_address"
1988version = "0.2.9"
1989source = "registry+https://github.com/rust-lang/crates.io-index"
1990checksum = "e079f19b08ca6239f47f8ba8509c11cf3ea30095831f7fed61441475edd8c449"
1991
1992[[package]]
1993name = "encoding_rs"
1994version = "0.8.35"
29291995source = "registry+https://github.com/rust-lang/crates.io-index"
2930checksum = "10d60334b3b2e7c9d91ef8150abfb6fa4c1c39ebbcf4a81c2e346aad939fee3e"
1996checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3"
29311997dependencies = [
2932 "thiserror 2.0.20",
1998 "cfg-if",
29331999]
29342000
29352001[[package]]
2936name = "delegate"
2937version = "0.13.5"
2002name = "enum_dispatch"
2003version = "0.3.13"
29382004source = "registry+https://github.com/rust-lang/crates.io-index"
2939checksum = "780eb241654bf097afb00fc5f054a09b687dad862e485fdcf8399bb056565370"
2005checksum = "aa18ce2bc66555b3218614519ac839ddb759a7d6720732f979ef8d13be147ecd"
29402006dependencies = [
2007 "once_cell",
29412008 "proc-macro2",
29422009 "quote",
29432010 "syn 2.0.119",
29442011]
29452012
29462013[[package]]
2947name = "der"
2948version = "0.7.10"
2014name = "equivalent"
2015version = "1.0.2"
29492016source = "registry+https://github.com/rust-lang/crates.io-index"
2950checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb"
2951dependencies = [
2952 "const-oid 0.9.6",
2953 "pem-rfc7468 0.7.0",
2954 "zeroize",
2955]
2017checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
29562018
29572019[[package]]
2958name = "der"
2959version = "0.8.1"
2020name = "errno"
2021version = "0.3.14"
29602022source = "registry+https://github.com/rust-lang/crates.io-index"
2961checksum = "a69dedd701da44b0536442edf09c81a64b0ab97a7a4a5e3d1971f00027cbc63d"
2023checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
29622024dependencies = [
2963 "const-oid 0.10.2",
2964 "pem-rfc7468 1.0.0",
2965 "zeroize",
2025 "libc",
2026 "windows-sys 0.61.2",
29662027]
29672028
29682029[[package]]
2969name = "deranged"
2970version = "0.5.8"
2030name = "etcetera"
2031version = "0.11.0"
29712032source = "registry+https://github.com/rust-lang/crates.io-index"
2972checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"
2033checksum = "de48cc4d1c1d97a20fd819def54b890cadde72ed3ad0c614822a0a433361be96"
29732034dependencies = [
2974 "serde_core",
2035 "cfg-if",
2036 "windows-sys 0.61.2",
29752037]
29762038
29772039[[package]]
2978name = "derive-where"
2979version = "1.6.1"
2040name = "event-listener"
2041version = "5.4.2"
29802042source = "registry+https://github.com/rust-lang/crates.io-index"
2981checksum = "d08b3a0bcc0d079199cd476b2cae8435016ec11d1c0986c6901c5ac223041534"
2043checksum = "5a23add41df1562121a9393cb065eab5146a1242410f23a644851e90cfd669d2"
29822044dependencies = [
2983 "proc-macro2",
2984 "quote",
2985 "syn 2.0.119",
2045 "parking",
2046 "pin-project-lite",
29862047]
29872048
29882049[[package]]
2989name = "derive_arbitrary"
2990version = "1.4.2"
2050name = "event-listener-strategy"
2051version = "0.5.4"
29912052source = "registry+https://github.com/rust-lang/crates.io-index"
2992checksum = "1e567bd82dcff979e4b03460c307b3cdc9e96fde3d73bed1496d2bc75d9dd62a"
2053checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"
29932054dependencies = [
2994 "proc-macro2",
2995 "quote",
2996 "syn 2.0.119",
2055 "event-listener",
2056 "pin-project-lite",
29972057]
29982058
29992059[[package]]
3000name = "derive_builder"
3001version = "0.20.2"
3002source = "registry+https://github.com/rust-lang/crates.io-index"
3003checksum = "507dfb09ea8b7fa618fcf76e953f4f5e192547945816d5358edffe39f6f94947"
2060name = "export"
2061version = "1.0.0"
30042062dependencies = [
3005 "derive_builder_macro",
2063 "axum",
2064 "bytes",
2065 "config",
2066 "email",
2067 "http-body-util",
2068 "rand 0.8.7",
2069 "redis",
2070 "sea-orm",
2071 "serde",
2072 "serde_json",
2073 "storage",
2074 "tokio",
2075 "tower",
2076 "tracing",
2077 "utoipa",
2078 "uuid",
30062079]
30072080
30082081[[package]]
3009name = "derive_builder_core"
3010version = "0.20.2"
2082name = "fast_chemail"
2083version = "0.9.6"
30112084source = "registry+https://github.com/rust-lang/crates.io-index"
3012checksum = "2d5bcf7b024d6835cfb3d473887cd966994907effbe9227e8c8219824d06c4e8"
2085checksum = "495a39d30d624c2caabe6312bfead73e7717692b44e0b32df168c275a2e8e9e4"
30132086dependencies = [
3014 "darling 0.20.11",
3015 "proc-macro2",
3016 "quote",
3017 "syn 2.0.119",
2087 "ascii_utils",
30182088]
30192089
30202090[[package]]
3021name = "derive_builder_macro"
3022version = "0.20.2"
2091name = "fastant"
2092version = "0.1.11"
30232093source = "registry+https://github.com/rust-lang/crates.io-index"
3024checksum = "ab63b0e2bf4d5928aff72e83a7dace85d7bba5fe12dcc3c5a572d78caffd3f3c"
2094checksum = "2e825441bfb2d831c47c97d05821552db8832479f44c571b97fededbf0099c07"
30252095dependencies = [
3026 "derive_builder_core",
3027 "syn 2.0.119",
2096 "small_ctor",
2097 "web-time",
30282098]
30292099
30302100[[package]]
3031name = "derive_more"
3032version = "2.1.1"
2101name = "fastbloom-rs"
2102version = "0.5.10"
30332103source = "registry+https://github.com/rust-lang/crates.io-index"
3034checksum = "d751e9e49156b02b44f9c1815bcb94b984cdcc4396ecc32521c739452808b134"
2104checksum = "1cedd8cf9a34b304cfa127370e66b51f85c412cf1a9cc15ec39fc1fe2912403a"
30352105dependencies = [
3036 "derive_more-impl",
2106 "cuckoofilter",
2107 "fastmurmur3",
2108 "xorfilter-rs",
2109 "xxhash-rust",
30372110]
30382111
30392112[[package]]
3040name = "derive_more-impl"
3041version = "2.1.1"
2113name = "faster-hex"
2114version = "0.10.0"
30422115source = "registry+https://github.com/rust-lang/crates.io-index"
3043checksum = "799a97264921d8623a957f6c3b9011f3b5492f557bbb7a5a19b7fa6d06ba8dcb"
2116checksum = "7223ae2d2f179b803433d9c830478527e92b8117eab39460edae7f1614d9fb73"
30442117dependencies = [
3045 "proc-macro2",
3046 "quote",
3047 "rustc_version",
3048 "syn 2.0.119",
3049 "unicode-xid",
2118 "heapless",
2119 "serde",
30502120]
30512121
30522122[[package]]
3053name = "des"
3054version = "0.9.0"
2123name = "fastmurmur3"
2124version = "0.2.0"
2125source = "registry+https://github.com/rust-lang/crates.io-index"
2126checksum = "2d7e9bc68be4cdabbb8938140b01a8b5bc1191937f2c7e7ecc2fcebbe2d749df"
2127
2128[[package]]
2129name = "fastrand"
2130version = "2.5.0"
30552131source = "registry+https://github.com/rust-lang/crates.io-index"
3056checksum = "916a94e407b54f9034d71dd748234cd1e516ced6284009906ae246f177eafe5a"
3057dependencies = [
3058 "cipher 0.5.2",
3059]
2132checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223"
30602133
30612134[[package]]
3062name = "digest"
3063version = "0.10.7"
2135name = "ff"
2136version = "0.13.1"
30642137source = "registry+https://github.com/rust-lang/crates.io-index"
3065checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
2138checksum = "c0b50bfb653653f9ca9095b427bed08ab8d75a137839d9ad64eb11810d5b6393"
30662139dependencies = [
3067 "block-buffer 0.10.4",
3068 "const-oid 0.9.6",
3069 "crypto-common 0.1.6",
2140 "rand_core 0.6.4",
30702141 "subtle",
30712142]
30722143
30732144[[package]]
3074name = "digest"
3075version = "0.11.3"
2145name = "ff"
2146version = "0.14.0"
30762147source = "registry+https://github.com/rust-lang/crates.io-index"
3077checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2"
2148checksum = "a1f686ab92a9fb0eaf188f6c6c87b89490baa6fdb0db4544ba4dc47f7942489f"
30782149dependencies = [
3079 "block-buffer 0.12.1",
3080 "const-oid 0.10.2",
3081 "crypto-common 0.2.2",
3082 "ctutils",
2150 "rand_core 0.10.1",
2151 "subtle",
30832152]
30842153
30852154[[package]]
3086name = "dirs"
3087version = "5.0.1"
2155name = "fiat-crypto"
2156version = "0.3.0"
30882157source = "registry+https://github.com/rust-lang/crates.io-index"
3089checksum = "44c45a9d03d6676652bcb5e724c7e988de1acad23a711b5217ab9cbecbec2225"
3090dependencies = [
3091 "dirs-sys 0.4.1",
3092]
2158checksum = "64cd1e32ddd350061ae6edb1b082d7c54915b5c672c389143b9a63403a109f24"
30932159
30942160[[package]]
3095name = "dirs"
3096version = "6.0.0"
2161name = "figment"
2162version = "0.10.19"
30972163source = "registry+https://github.com/rust-lang/crates.io-index"
3098checksum = "c3e8aa94d75141228480295a7d0e7feb620b1a5ad9f12bc40be62411e38cce4e"
2164checksum = "8cb01cd46b0cf372153850f4c6c272d9cbea2da513e07538405148f95bd789f3"
30992165dependencies = [
3100 "dirs-sys 0.5.0",
2166 "atomic",
2167 "pear",
2168 "serde",
2169 "toml",
2170 "uncased",
2171 "version_check 0.9.5",
31012172]
31022173
31032174[[package]]
3104name = "dirs-sys"
3105version = "0.4.1"
2175name = "filetime"
2176version = "0.2.29"
31062177source = "registry+https://github.com/rust-lang/crates.io-index"
3107checksum = "520f05a5cbd335fae5a99ff7a6ab8627577660ee5cfd6a94a6a929b52ff0321c"
2178checksum = "5c287a33c7f0a620c38e641e7f60827713987b3c0f26e8ddc9462cc69cf75759"
31082179dependencies = [
2180 "cfg-if",
31092181 "libc",
3110 "option-ext",
3111 "redox_users 0.4.6",
3112 "windows-sys 0.48.0",
31132182]
31142183
31152184[[package]]
3116name = "dirs-sys"
3117version = "0.5.0"
2185name = "find-msvc-tools"
2186version = "0.1.11"
31182187source = "registry+https://github.com/rust-lang/crates.io-index"
3119checksum = "e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab"
3120dependencies = [
3121 "libc",
3122 "option-ext",
3123 "redox_users 0.5.2",
3124 "windows-sys 0.61.2",
3125]
2188checksum = "d45db016d36b838f563236e9193d0ee6ce38f3f68b6c94e914b4929c96bbb890"
31262189
31272190[[package]]
3128name = "displaydoc"
3129version = "0.2.7"
2191name = "fixed_decimal"
2192version = "0.7.2"
31302193source = "registry+https://github.com/rust-lang/crates.io-index"
3131checksum = "c6232dd377dcc64799954cbd3a9bb882e9cdc1308ccd87b1c098f1fb2eaf82a8"
2194checksum = "79c3c892f121fff406e5dd6b28c1b30096b95111c30701a899d4f2b18da6d1bd"
31322195dependencies = [
3133 "proc-macro2",
3134 "quote",
3135 "syn 3.0.3",
2196 "displaydoc",
2197 "smallvec",
2198 "writeable",
31362199]
31372200
31382201[[package]]
3139name = "dlv-list"
3140version = "0.3.0"
2202name = "flate2"
2203version = "1.1.9"
31412204source = "registry+https://github.com/rust-lang/crates.io-index"
3142checksum = "0688c2a7f92e427f44895cd63841bff7b29f8d7a1648b9e7e07a4a365b2e1257"
2205checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"
2206dependencies = [
2207 "crc32fast",
2208 "miniz_oxide",
2209 "zlib-rs",
2210]
31432211
31442212[[package]]
3145name = "dotenvy"
3146version = "0.15.7"
2213name = "flume"
2214version = "0.12.0"
31472215source = "registry+https://github.com/rust-lang/crates.io-index"
3148checksum = "1aaf95b3e5c8f23aa320147307562d361db0ae0d51242340f558153b4eb2439b"
2216checksum = "5e139bc46ca777eb5efaf62df0ab8cc5fd400866427e56c68b22e414e53bd3be"
2217dependencies = [
2218 "futures-core",
2219 "futures-sink",
2220 "spin",
2221]
31492222
31502223[[package]]
3151name = "dunce"
3152version = "1.0.5"
2224name = "fnv"
2225version = "1.0.7"
31532226source = "registry+https://github.com/rust-lang/crates.io-index"
3154checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813"
2227checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
31552228
31562229[[package]]
3157name = "dyn-clone"
3158version = "1.0.20"
2230name = "foldhash"
2231version = "0.2.0"
31592232source = "registry+https://github.com/rust-lang/crates.io-index"
3160checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555"
2233checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
31612234
31622235[[package]]
3163name = "ecdsa"
3164version = "0.16.9"
2236name = "foreign-types"
2237version = "0.3.2"
31652238source = "registry+https://github.com/rust-lang/crates.io-index"
3166checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca"
2239checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
31672240dependencies = [
3168 "der 0.7.10",
3169 "digest 0.10.7",
3170 "elliptic-curve 0.13.8",
3171 "rfc6979 0.4.0",
3172 "signature 2.2.0",
3173 "spki 0.7.3",
2241 "foreign-types-shared",
31742242]
31752243
31762244[[package]]
3177name = "ecdsa"
3178version = "0.17.0"
2245name = "foreign-types-shared"
2246version = "0.1.1"
31792247source = "registry+https://github.com/rust-lang/crates.io-index"
3180checksum = "c0681a4fc24c767085329728d8dfba959af91228aa4610cca4f8ce317ba46ae0"
3181dependencies = [
3182 "der 0.8.1",
3183 "digest 0.11.3",
3184 "elliptic-curve 0.14.1",
3185 "rfc6979 0.6.0",
3186 "signature 3.0.0",
3187 "spki 0.8.0",
3188 "zeroize",
3189]
2248checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
31902249
31912250[[package]]
3192name = "ed25519"
3193version = "2.2.3"
2251name = "form_urlencoded"
2252version = "1.2.2"
31942253source = "registry+https://github.com/rust-lang/crates.io-index"
3195checksum = "115531babc129696a58c64a4fef0a8bf9e9698629fb97e9e40767d235cfbcd53"
2254checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
31962255dependencies = [
3197 "signature 2.2.0",
2256 "percent-encoding 2.3.2",
31982257]
31992258
32002259[[package]]
3201name = "ed25519"
3202version = "3.0.0"
2260name = "forwarded-header-value"
2261version = "0.1.1"
32032262source = "registry+https://github.com/rust-lang/crates.io-index"
3204checksum = "29fcf32e6c73d1079f83ab4d782de2d81620346a5f38c6237a86a22f8368980a"
2263checksum = "8835f84f38484cc86f110a805655697908257fb9a7af005234060891557198e9"
32052264dependencies = [
3206 "pkcs8 0.11.0",
3207 "signature 3.0.0",
2265 "nonempty 0.7.0",
2266 "thiserror 1.0.69",
32082267]
32092268
32102269[[package]]
3211name = "ed25519-dalek"
3212version = "2.2.0"
2270name = "foyer"
2271version = "0.22.3"
32132272source = "registry+https://github.com/rust-lang/crates.io-index"
3214checksum = "70e796c081cee67dc755e1a36a0a172b897fab85fc3f6bc48307991f64e4eca9"
2273checksum = "3b0abc0b87814989efa711f9becd9f26969820e2d3905db27d10969c4bd45890"
32152274dependencies = [
3216 "curve25519-dalek 4.1.3",
3217 "ed25519 2.2.3",
3218 "sha2 0.10.9",
3219 "signature 2.2.0",
3220 "subtle",
2275 "anyhow",
2276 "equivalent",
2277 "foyer-common",
2278 "foyer-memory",
2279 "foyer-storage",
2280 "foyer-tokio",
2281 "futures-util",
2282 "mea",
2283 "mixtrics",
2284 "pin-project",
2285 "serde",
2286 "tracing",
32212287]
32222288
32232289[[package]]
3224name = "ed25519-dalek"
3225version = "3.0.0"
2290name = "foyer-common"
2291version = "0.22.3"
32262292source = "registry+https://github.com/rust-lang/crates.io-index"
3227checksum = "6ebaa1a2bf1290ab3bfe5a7b771d050ebffab2711c19a81691c683a5144a25de"
2293checksum = "a3db80d5dece93adb7ad709c84578794724a9cba342a7e566c3551c7ec626789"
32282294dependencies = [
3229 "curve25519-dalek 5.0.0",
3230 "ed25519 3.0.0",
3231 "rand_core 0.10.1",
3232 "serde",
3233 "sha2 0.11.0",
3234 "signature 3.0.0",
3235 "subtle",
3236 "zeroize",
2295 "anyhow",
2296 "bytes",
2297 "cfg-if",
2298 "foyer-tokio",
2299 "mixtrics",
2300 "parking_lot",
2301 "pin-project",
2302 "twox-hash",
32372303]
32382304
32392305[[package]]
3240name = "either"
3241version = "1.17.0"
2306name = "foyer-intrusive-collections"
2307version = "0.10.0-dev"
32422308source = "registry+https://github.com/rust-lang/crates.io-index"
3243checksum = "9e5e8f6c15a24b9a3ee5efec809ccd006d3b30e8b3bb63c39af737c7f87daa1d"
2309checksum = "6e4fee46bea69e0596130e3210e65d3424e0ac1e6df3bde6636304bdf1ca4a3b"
32442310dependencies = [
3245 "serde",
2311 "memoffset",
32462312]
32472313
32482314[[package]]
3249name = "elliptic-curve"
3250version = "0.13.8"
2315name = "foyer-memory"
2316version = "0.22.3"
32512317source = "registry+https://github.com/rust-lang/crates.io-index"
3252checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47"
2318checksum = "db907f40a527ca2aa2f40a5f68b32ea58aa70f050cd233518e9ffd402cfba6ce"
32532319dependencies = [
3254 "base16ct 0.2.0",
3255 "crypto-bigint 0.5.5",
3256 "digest 0.10.7",
3257 "ff 0.13.1",
3258 "generic-array 0.14.9",
3259 "group 0.13.0",
3260 "pkcs8 0.10.2",
3261 "rand_core 0.6.4",
3262 "sec1 0.7.3",
3263 "subtle",
3264 "zeroize",
2320 "anyhow",
2321 "bitflags 2.13.1",
2322 "cmsketch",
2323 "equivalent",
2324 "foyer-common",
2325 "foyer-intrusive-collections",
2326 "foyer-tokio",
2327 "futures-util",
2328 "hashbrown 0.16.1",
2329 "itertools 0.14.0",
2330 "mea",
2331 "mixtrics",
2332 "parking_lot",
2333 "paste",
2334 "pin-project",
2335 "serde",
2336 "tracing",
32652337]
32662338
32672339[[package]]
3268name = "elliptic-curve"
3269version = "0.14.1"
2340name = "foyer-storage"
2341version = "0.22.3"
32702342source = "registry+https://github.com/rust-lang/crates.io-index"
3271checksum = "9d65aa39b3a5c1c9c1b745c9a019234bb7a21b77abcb4f4d266d706e2d577d65"
2343checksum = "1983f1db3d0710e9c9d5fc116d9202dccd41a2d1e032572224f1aff5520aa958"
32722344dependencies = [
3273 "base16ct 1.0.0",
3274 "crypto-bigint 0.7.5",
3275 "crypto-common 0.2.2",
3276 "digest 0.11.3",
3277 "ff 0.14.0",
3278 "group 0.14.0",
3279 "hkdf",
3280 "hybrid-array",
3281 "pem-rfc7468 1.0.0",
3282 "pkcs8 0.11.0",
3283 "rand_core 0.10.1",
3284 "sec1 0.8.1",
3285 "subtle",
3286 "zeroize",
2345 "allocator-api2",
2346 "anyhow",
2347 "bytes",
2348 "core_affinity",
2349 "equivalent",
2350 "fastant",
2351 "foyer-common",
2352 "foyer-memory",
2353 "foyer-tokio",
2354 "fs4",
2355 "futures-core",
2356 "futures-util",
2357 "hashbrown 0.16.1",
2358 "io-uring",
2359 "itertools 0.14.0",
2360 "libc",
2361 "lz4",
2362 "mea",
2363 "parking_lot",
2364 "pin-project",
2365 "rand 0.9.5",
2366 "tracing",
2367 "twox-hash",
2368 "zstd",
32872369]
32882370
32892371[[package]]
3290name = "email"
3291version = "1.0.0"
2372name = "foyer-tokio"
2373version = "0.22.3"
2374source = "registry+https://github.com/rust-lang/crates.io-index"
2375checksum = "f6577b05a7ffad0db555aedf00bfe52af818220fc4c1c3a7a12520896fc38627"
32922376dependencies = [
3293 "async-trait",
3294 "base64 0.23.1",
3295 "bytes",
3296 "config",
3297 "futures",
3298 "lettre",
3299 "maud",
3300 "redis",
3301 "serde",
3302 "serde_json",
3303 "time 0.3.55",
33042377 "tokio",
3305 "tokio-util",
3306 "tracing",
3307 "uuid",
33082378]
33092379
33102380[[package]]
3311name = "email-encoding"
3312version = "0.4.2"
2381name = "fs4"
2382version = "0.13.1"
33132383source = "registry+https://github.com/rust-lang/crates.io-index"
3314checksum = "420b9da095f052ea597503e39073b5b3c522f7db933fbac202d91d24492693fd"
2384checksum = "8640e34b88f7652208ce9e88b1a37a2ae95227d84abec377ccd3c5cfeb141ed4"
33152385dependencies = [
3316 "base64 0.23.1",
3317 "memchr",
2386 "rustix",
2387 "windows-sys 0.59.0",
33182388]
33192389
33202390[[package]]
3321name = "email_address"
3322version = "0.2.9"
2391name = "fs_extra"
2392version = "1.3.0"
33232393source = "registry+https://github.com/rust-lang/crates.io-index"
3324checksum = "e079f19b08ca6239f47f8ba8509c11cf3ea30095831f7fed61441475edd8c449"
2394checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"
33252395
33262396[[package]]
3327name = "encode_unicode"
3328version = "1.0.0"
2397name = "funty"
2398version = "2.0.0"
33292399source = "registry+https://github.com/rust-lang/crates.io-index"
3330checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"
2400checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
33312401
33322402[[package]]
3333name = "encoding_rs"
3334version = "0.8.35"
2403name = "futures"
2404version = "0.3.34"
33352405source = "registry+https://github.com/rust-lang/crates.io-index"
3336checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3"
2406checksum = "9a31d2a3fbaaeb2af2368bbdd904aa8e812d3c04a1ee10d3171f52d556e5d0a3"
33372407dependencies = [
3338 "cfg-if",
2408 "futures-channel",
2409 "futures-core",
2410 "futures-executor",
2411 "futures-io",
2412 "futures-sink",
2413 "futures-task",
2414 "futures-util",
33392415]
33402416
33412417[[package]]
3342name = "encoding_rs_io"
3343version = "0.1.8"
2418name = "futures-channel"
2419version = "0.3.34"
33442420source = "registry+https://github.com/rust-lang/crates.io-index"
3345checksum = "fba3fe847045ecff794b9c138293a80db914678c453ad63fbf0c6a9eb6e00b22"
2421checksum = "b1f9e3d69d39e4862ffed03ed071a76f9a13ba1d9109d355b0f0aa6b15e393c4"
33462422dependencies = [
3347 "encoding_rs",
2423 "futures-core",
2424 "futures-sink",
33482425]
33492426
33502427[[package]]
3351name = "enum_dispatch"
3352version = "0.3.13"
2428name = "futures-core"
2429version = "0.3.34"
33532430source = "registry+https://github.com/rust-lang/crates.io-index"
3354checksum = "aa18ce2bc66555b3218614519ac839ddb759a7d6720732f979ef8d13be147ecd"
3355dependencies = [
3356 "once_cell",
3357 "proc-macro2",
3358 "quote",
3359 "syn 2.0.119",
3360]
2431checksum = "92d699e522242e69e3003b94ecc1f960f3a5e015aa7c5d7486e65ad01dd94f5e"
33612432
33622433[[package]]
3363name = "equator"
3364version = "0.4.2"
2434name = "futures-executor"
2435version = "0.3.34"
33652436source = "registry+https://github.com/rust-lang/crates.io-index"
3366checksum = "4711b213838dfee0117e3be6ac926007d7f433d7bbe33595975d4190cb07e6fc"
2437checksum = "031b47cf1a3c6cc8bc2fc76cd437f521619387907d469316e7c0bc278f1f5432"
33672438dependencies = [
3368 "equator-macro",
2439 "futures-core",
2440 "futures-task",
2441 "futures-util",
33692442]
33702443
33712444[[package]]
3372name = "equator-macro"
3373version = "0.4.2"
2445name = "futures-intrusive"
2446version = "0.5.0"
33742447source = "registry+https://github.com/rust-lang/crates.io-index"
3375checksum = "44f23cf4b44bfce11a86ace86f8a73ffdec849c9fd00a386a53d278bd9e81fb3"
2448checksum = "1d930c203dd0b6ff06e0201a4a2fe9149b43c684fd4420555b26d21b1a02956f"
33762449dependencies = [
3377 "proc-macro2",
3378 "quote",
3379 "syn 2.0.119",
2450 "futures-core",
2451 "lock_api",
2452 "parking_lot",
33802453]
33812454
33822455[[package]]
3383name = "equivalent"
3384version = "1.0.2"
2456name = "futures-io"
2457version = "0.3.34"
33852458source = "registry+https://github.com/rust-lang/crates.io-index"
3386checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
2459checksum = "53c0fa8157de1303bfffdaa1cc2a673bfffb60102f76b0ef4441659124373fed"
33872460
33882461[[package]]
3389name = "errno"
3390version = "0.3.14"
2462name = "futures-lite"
2463version = "2.6.1"
33912464source = "registry+https://github.com/rust-lang/crates.io-index"
3392checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
2465checksum = "f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad"
33932466dependencies = [
3394 "libc",
3395 "windows-sys 0.61.2",
2467 "futures-core",
2468 "pin-project-lite",
33962469]
33972470
33982471[[package]]
3399name = "esaxx-rs"
3400version = "0.1.10"
2472name = "futures-macro"
2473version = "0.3.34"
34012474source = "registry+https://github.com/rust-lang/crates.io-index"
3402checksum = "d817e038c30374a4bcb22f94d0a8a0e216958d4c3dcde369b1439fec4bdda6e6"
2475checksum = "9fb9654ba8355388abeb8dcb4fc62f511300867002afc858860463bdd9fe0c44"
2476dependencies = [
2477 "proc-macro2",
2478 "quote",
2479 "syn 3.0.3",
2480]
34032481
34042482[[package]]
3405name = "etcetera"
3406version = "0.11.0"
2483name = "futures-sink"
2484version = "0.3.34"
34072485source = "registry+https://github.com/rust-lang/crates.io-index"
3408checksum = "de48cc4d1c1d97a20fd819def54b890cadde72ed3ad0c614822a0a433361be96"
3409dependencies = [
3410 "cfg-if",
3411 "windows-sys 0.61.2",
3412]
2486checksum = "1944426bf7d03f1d14f708785e4b33efd750b36d48a157b836b3efc15ede8e1d"
34132487
34142488[[package]]
3415name = "ethnum"
3416version = "1.5.3"
2489name = "futures-task"
2490version = "0.3.34"
34172491source = "registry+https://github.com/rust-lang/crates.io-index"
3418checksum = "40404c3f5f511ec4da6fe866ddf6a717c309fdbb69fbbad7b0f3edab8f2e835f"
2492checksum = "cd417de3d1d015fc3bfd2b1ea46dfc7bab72ef86f1cc7cc9c78e728b34a6d1fd"
34192493
34202494[[package]]
3421name = "event-listener"
3422version = "5.4.2"
2495name = "futures-util"
2496version = "0.3.34"
34232497source = "registry+https://github.com/rust-lang/crates.io-index"
3424checksum = "5a23add41df1562121a9393cb065eab5146a1242410f23a644851e90cfd669d2"
2498checksum = "0d50a92467f8ba5dd6e3ee5d4bd04d73ab2e4e1c44474a0674821dfce14b79bc"
34252499dependencies = [
3426 "parking",
2500 "futures-channel",
2501 "futures-core",
2502 "futures-io",
2503 "futures-macro",
2504 "futures-sink",
2505 "futures-task",
2506 "memchr",
34272507 "pin-project-lite",
2508 "slab",
34282509]
34292510
34302511[[package]]
3431name = "event-listener-strategy"
3432version = "0.5.4"
2512name = "generic-array"
2513version = "0.14.9"
34332514source = "registry+https://github.com/rust-lang/crates.io-index"
3434checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"
2515checksum = "4bb6743198531e02858aeaea5398fcc883e71851fcbcb5a2f773e2fb6cb1edf2"
34352516dependencies = [
3436 "event-listener",
3437 "pin-project-lite",
2517 "typenum",
2518 "version_check 0.9.5",
2519 "zeroize",
34382520]
34392521
34402522[[package]]
3441name = "eventsource-stream"
3442version = "0.2.3"
2523name = "generic-array"
2524version = "1.4.5"
34432525source = "registry+https://github.com/rust-lang/crates.io-index"
3444checksum = "74fef4569247a5f429d9156b9d0a2599914385dd189c539334c625d8099d90ab"
2526checksum = "337d46834ee672ab3e48caca2cb0c78cc174fb12b3a68d0d88f99a0519a5e36e"
34452527dependencies = [
3446 "futures-core",
3447 "nom 7.1.3",
3448 "pin-project-lite",
2528 "generic-array 0.14.9",
2529 "rustversion",
2530 "typenum",
34492531]
34502532
34512533[[package]]
3452name = "export"
3453version = "1.0.0"
2534name = "getrandom"
2535version = "0.1.16"
2536source = "registry+https://github.com/rust-lang/crates.io-index"
2537checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce"
34542538dependencies = [
3455 "async-nats",
3456 "axum",
3457 "bytes",
3458 "config",
3459 "email",
3460 "http-body-util",
3461 "rand 0.8.7",
3462 "redis",
3463 "sea-orm",
3464 "serde",
3465 "serde_json",
3466 "storage",
3467 "tokio",
3468 "tower",
3469 "tracing",
3470 "utoipa",
3471 "uuid",
2539 "cfg-if",
2540 "libc",
2541 "wasi 0.9.0+wasi-snapshot-preview1",
34722542]
34732543
34742544[[package]]
3475name = "exr"
3476version = "1.74.2"
2545name = "getrandom"
2546version = "0.2.17"
34772547source = "registry+https://github.com/rust-lang/crates.io-index"
3478checksum = "711fe42c9964295e01ee3fba3f9fe0e1d24b98886950d68efe81b1c76e21adf3"
2548checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
34792549dependencies = [
3480 "bit_field",
3481 "half",
3482 "lebe",
3483 "miniz_oxide",
3484 "num-complex",
3485 "pulp",
3486 "rayon-core",
3487 "smallvec",
3488 "zune-inflate",
2550 "cfg-if",
2551 "js-sys",
2552 "libc",
2553 "wasi 0.11.1+wasi-snapshot-preview1",
2554 "wasm-bindgen",
34892555]
34902556
34912557[[package]]
3492name = "fast-float2"
3493version = "0.2.4"
2558name = "getrandom"
2559version = "0.3.4"
34942560source = "registry+https://github.com/rust-lang/crates.io-index"
3495checksum = "c6e8948ce679d00a02a94739ea185595dca7118ed04feb991127e443bd3d761f"
3496
3497[[package]]
3498name = "fast_chemail"
3499version = "0.9.6"
3500source = "registry+https://github.com/rust-lang/crates.io-index"
3501checksum = "495a39d30d624c2caabe6312bfead73e7717692b44e0b32df168c275a2e8e9e4"
2561checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
35022562dependencies = [
3503 "ascii_utils",
3504]
3505
3506[[package]]
3507name = "fastant"
3508version = "0.1.11"
3509source = "registry+https://github.com/rust-lang/crates.io-index"
3510checksum = "2e825441bfb2d831c47c97d05821552db8832479f44c571b97fededbf0099c07"
3511dependencies = [
3512 "small_ctor",
3513 "web-time",
3514]
3515
3516[[package]]
3517name = "fastbloom-rs"
3518version = "0.5.10"
3519source = "registry+https://github.com/rust-lang/crates.io-index"
3520checksum = "1cedd8cf9a34b304cfa127370e66b51f85c412cf1a9cc15ec39fc1fe2912403a"
3521dependencies = [
3522 "cuckoofilter",
3523 "fastmurmur3",
3524 "xorfilter-rs",
3525 "xxhash-rust",
3526]
3527
3528[[package]]
3529name = "fastembed"
3530version = "4.9.1"
3531source = "registry+https://github.com/rust-lang/crates.io-index"
3532checksum = "04c269a76bfc6cea69553b7d040acb16c793119cebd97c756d21e08d0f075ff8"
3533dependencies = [
3534 "anyhow",
3535 "hf-hub",
3536 "image",
3537 "ndarray",
3538 "ort",
3539 "ort-sys",
3540 "rayon",
3541 "serde_json",
3542 "tokenizers",
3543]
3544
3545[[package]]
3546name = "faster-hex"
3547version = "0.10.0"
3548source = "registry+https://github.com/rust-lang/crates.io-index"
3549checksum = "7223ae2d2f179b803433d9c830478527e92b8117eab39460edae7f1614d9fb73"
3550dependencies = [
3551 "heapless",
3552 "serde",
3553]
3554
3555[[package]]
3556name = "fastmurmur3"
3557version = "0.2.0"
3558source = "registry+https://github.com/rust-lang/crates.io-index"
3559checksum = "2d7e9bc68be4cdabbb8938140b01a8b5bc1191937f2c7e7ecc2fcebbe2d749df"
3560
3561[[package]]
3562name = "fastrand"
3563version = "2.5.0"
3564source = "registry+https://github.com/rust-lang/crates.io-index"
3565checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223"
3566
3567[[package]]
3568name = "fax"
3569version = "0.2.7"
3570source = "registry+https://github.com/rust-lang/crates.io-index"
3571checksum = "caf1079563223d5d59d83c85886a56e586cfd5c1a26292e971a0fa266531ac5a"
3572
3573[[package]]
3574name = "fdeflate"
3575version = "0.3.7"
3576source = "registry+https://github.com/rust-lang/crates.io-index"
3577checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c"
3578dependencies = [
3579 "simd-adler32",
3580]
3581
3582[[package]]
3583name = "ff"
3584version = "0.13.1"
3585source = "registry+https://github.com/rust-lang/crates.io-index"
3586checksum = "c0b50bfb653653f9ca9095b427bed08ab8d75a137839d9ad64eb11810d5b6393"
3587dependencies = [
3588 "rand_core 0.6.4",
3589 "subtle",
3590]
3591
3592[[package]]
3593name = "ff"
3594version = "0.14.0"
3595source = "registry+https://github.com/rust-lang/crates.io-index"
3596checksum = "a1f686ab92a9fb0eaf188f6c6c87b89490baa6fdb0db4544ba4dc47f7942489f"
3597dependencies = [
3598 "rand_core 0.10.1",
3599 "subtle",
3600]
3601
3602[[package]]
3603name = "fiat-crypto"
3604version = "0.2.9"
3605source = "registry+https://github.com/rust-lang/crates.io-index"
3606checksum = "28dea519a9695b9977216879a3ebfddf92f1c08c05d984f8996aecd6ecdc811d"
3607
3608[[package]]
3609name = "fiat-crypto"
3610version = "0.3.0"
3611source = "registry+https://github.com/rust-lang/crates.io-index"
3612checksum = "64cd1e32ddd350061ae6edb1b082d7c54915b5c672c389143b9a63403a109f24"
3613
3614[[package]]
3615name = "figment"
3616version = "0.10.19"
3617source = "registry+https://github.com/rust-lang/crates.io-index"
3618checksum = "8cb01cd46b0cf372153850f4c6c272d9cbea2da513e07538405148f95bd789f3"
3619dependencies = [
3620 "atomic",
3621 "pear",
3622 "serde",
3623 "toml",
3624 "uncased",
3625 "version_check 0.9.5",
3626]
3627
3628[[package]]
3629name = "filetime"
3630version = "0.2.29"
3631source = "registry+https://github.com/rust-lang/crates.io-index"
3632checksum = "5c287a33c7f0a620c38e641e7f60827713987b3c0f26e8ddc9462cc69cf75759"
3633dependencies = [
3634 "cfg-if",
3635 "libc",
3636]
3637
3638[[package]]
3639name = "find-msvc-tools"
3640version = "0.1.11"
3641source = "registry+https://github.com/rust-lang/crates.io-index"
3642checksum = "d45db016d36b838f563236e9193d0ee6ce38f3f68b6c94e914b4929c96bbb890"
3643
3644[[package]]
3645name = "fixed_decimal"
3646version = "0.7.2"
3647source = "registry+https://github.com/rust-lang/crates.io-index"
3648checksum = "79c3c892f121fff406e5dd6b28c1b30096b95111c30701a899d4f2b18da6d1bd"
3649dependencies = [
3650 "displaydoc",
3651 "smallvec",
3652 "writeable",
3653]
3654
3655[[package]]
3656name = "fixedbitset"
3657version = "0.5.7"
3658source = "registry+https://github.com/rust-lang/crates.io-index"
3659checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
3660
3661[[package]]
3662name = "flatbuffers"
3663version = "25.12.19"
3664source = "registry+https://github.com/rust-lang/crates.io-index"
3665checksum = "35f6839d7b3b98adde531effaf34f0c2badc6f4735d26fe74709d8e513a96ef3"
3666dependencies = [
3667 "bitflags 2.13.1",
3668 "rustc_version",
3669]
3670
3671[[package]]
3672name = "flate2"
3673version = "1.1.9"
3674source = "registry+https://github.com/rust-lang/crates.io-index"
3675checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"
3676dependencies = [
3677 "crc32fast",
3678 "miniz_oxide",
3679 "zlib-rs",
3680]
3681
3682[[package]]
3683name = "flume"
3684version = "0.12.0"
3685source = "registry+https://github.com/rust-lang/crates.io-index"
3686checksum = "5e139bc46ca777eb5efaf62df0ab8cc5fd400866427e56c68b22e414e53bd3be"
3687dependencies = [
3688 "futures-core",
3689 "futures-sink",
3690 "spin",
3691]
3692
3693[[package]]
3694name = "fnv"
3695version = "1.0.7"
3696source = "registry+https://github.com/rust-lang/crates.io-index"
3697checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
3698
3699[[package]]
3700name = "foldhash"
3701version = "0.1.5"
3702source = "registry+https://github.com/rust-lang/crates.io-index"
3703checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
3704
3705[[package]]
3706name = "foldhash"
3707version = "0.2.0"
3708source = "registry+https://github.com/rust-lang/crates.io-index"
3709checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
3710
3711[[package]]
3712name = "foreign-types"
3713version = "0.3.2"
3714source = "registry+https://github.com/rust-lang/crates.io-index"
3715checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
3716dependencies = [
3717 "foreign-types-shared",
3718]
3719
3720[[package]]
3721name = "foreign-types-shared"
3722version = "0.1.1"
3723source = "registry+https://github.com/rust-lang/crates.io-index"
3724checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
3725
3726[[package]]
3727name = "form_urlencoded"
3728version = "1.2.2"
3729source = "registry+https://github.com/rust-lang/crates.io-index"
3730checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
3731dependencies = [
3732 "percent-encoding 2.3.2",
3733]
3734
3735[[package]]
3736name = "forwarded-header-value"
3737version = "0.1.1"
3738source = "registry+https://github.com/rust-lang/crates.io-index"
3739checksum = "8835f84f38484cc86f110a805655697908257fb9a7af005234060891557198e9"
3740dependencies = [
3741 "nonempty 0.7.0",
3742 "thiserror 1.0.69",
3743]
3744
3745[[package]]
3746name = "foyer"
3747version = "0.22.3"
3748source = "registry+https://github.com/rust-lang/crates.io-index"
3749checksum = "3b0abc0b87814989efa711f9becd9f26969820e2d3905db27d10969c4bd45890"
3750dependencies = [
3751 "anyhow",
3752 "equivalent",
3753 "foyer-common",
3754 "foyer-memory",
3755 "foyer-storage",
3756 "foyer-tokio",
3757 "futures-util",
3758 "mea",
3759 "mixtrics",
3760 "pin-project",
3761 "serde",
3762 "tracing",
3763]
3764
3765[[package]]
3766name = "foyer-common"
3767version = "0.22.3"
3768source = "registry+https://github.com/rust-lang/crates.io-index"
3769checksum = "a3db80d5dece93adb7ad709c84578794724a9cba342a7e566c3551c7ec626789"
3770dependencies = [
3771 "anyhow",
3772 "bytes",
3773 "cfg-if",
3774 "foyer-tokio",
3775 "mixtrics",
3776 "parking_lot",
3777 "pin-project",
3778 "twox-hash",
3779]
3780
3781[[package]]
3782name = "foyer-intrusive-collections"
3783version = "0.10.0-dev"
3784source = "registry+https://github.com/rust-lang/crates.io-index"
3785checksum = "6e4fee46bea69e0596130e3210e65d3424e0ac1e6df3bde6636304bdf1ca4a3b"
3786dependencies = [
3787 "memoffset",
3788]
3789
3790[[package]]
3791name = "foyer-memory"
3792version = "0.22.3"
3793source = "registry+https://github.com/rust-lang/crates.io-index"
3794checksum = "db907f40a527ca2aa2f40a5f68b32ea58aa70f050cd233518e9ffd402cfba6ce"
3795dependencies = [
3796 "anyhow",
3797 "bitflags 2.13.1",
3798 "cmsketch",
3799 "equivalent",
3800 "foyer-common",
3801 "foyer-intrusive-collections",
3802 "foyer-tokio",
3803 "futures-util",
3804 "hashbrown 0.16.1",
3805 "itertools 0.14.0",
3806 "mea",
3807 "mixtrics",
3808 "parking_lot",
3809 "paste",
3810 "pin-project",
3811 "serde",
3812 "tracing",
3813]
3814
3815[[package]]
3816name = "foyer-storage"
3817version = "0.22.3"
3818source = "registry+https://github.com/rust-lang/crates.io-index"
3819checksum = "1983f1db3d0710e9c9d5fc116d9202dccd41a2d1e032572224f1aff5520aa958"
3820dependencies = [
3821 "allocator-api2",
3822 "anyhow",
3823 "bytes",
3824 "core_affinity",
3825 "equivalent",
3826 "fastant",
3827 "foyer-common",
3828 "foyer-memory",
3829 "foyer-tokio",
3830 "fs4",
3831 "futures-core",
3832 "futures-util",
3833 "hashbrown 0.16.1",
3834 "io-uring",
3835 "itertools 0.14.0",
3836 "libc",
3837 "lz4",
3838 "mea",
3839 "parking_lot",
3840 "pin-project",
3841 "rand 0.9.5",
3842 "tracing",
3843 "twox-hash",
3844 "zstd",
3845]
3846
3847[[package]]
3848name = "foyer-tokio"
3849version = "0.22.3"
3850source = "registry+https://github.com/rust-lang/crates.io-index"
3851checksum = "f6577b05a7ffad0db555aedf00bfe52af818220fc4c1c3a7a12520896fc38627"
3852dependencies = [
3853 "tokio",
3854]
3855
3856[[package]]
3857name = "fs4"
3858version = "0.13.1"
3859source = "registry+https://github.com/rust-lang/crates.io-index"
3860checksum = "8640e34b88f7652208ce9e88b1a37a2ae95227d84abec377ccd3c5cfeb141ed4"
3861dependencies = [
3862 "rustix",
3863 "windows-sys 0.59.0",
3864]
3865
3866[[package]]
3867name = "fs_extra"
3868version = "1.3.0"
3869source = "registry+https://github.com/rust-lang/crates.io-index"
3870checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"
3871
3872[[package]]
3873name = "fsst"
3874version = "7.0.0"
3875source = "registry+https://github.com/rust-lang/crates.io-index"
3876checksum = "bcd0ce0249ac12fd44fcde62d435c36d881952c2f0df4d1de24b45e1dbba5ddb"
3877dependencies = [
3878 "arrow-array",
3879 "rand 0.9.5",
3880]
3881
3882[[package]]
3883name = "fst"
3884version = "0.4.7"
3885source = "registry+https://github.com/rust-lang/crates.io-index"
3886checksum = "7ab85b9b05e3978cc9a9cf8fea7f01b494e1a09ed3037e16ba39edc7a29eb61a"
3887dependencies = [
3888 "utf8-ranges",
3889]
3890
3891[[package]]
3892name = "funty"
3893version = "2.0.0"
3894source = "registry+https://github.com/rust-lang/crates.io-index"
3895checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
3896
3897[[package]]
3898name = "futures"
3899version = "0.3.34"
3900source = "registry+https://github.com/rust-lang/crates.io-index"
3901checksum = "9a31d2a3fbaaeb2af2368bbdd904aa8e812d3c04a1ee10d3171f52d556e5d0a3"
3902dependencies = [
3903 "futures-channel",
3904 "futures-core",
3905 "futures-executor",
3906 "futures-io",
3907 "futures-sink",
3908 "futures-task",
3909 "futures-util",
3910]
3911
3912[[package]]
3913name = "futures-channel"
3914version = "0.3.34"
3915source = "registry+https://github.com/rust-lang/crates.io-index"
3916checksum = "b1f9e3d69d39e4862ffed03ed071a76f9a13ba1d9109d355b0f0aa6b15e393c4"
3917dependencies = [
3918 "futures-core",
3919 "futures-sink",
3920]
3921
3922[[package]]
3923name = "futures-core"
3924version = "0.3.34"
3925source = "registry+https://github.com/rust-lang/crates.io-index"
3926checksum = "92d699e522242e69e3003b94ecc1f960f3a5e015aa7c5d7486e65ad01dd94f5e"
3927
3928[[package]]
3929name = "futures-executor"
3930version = "0.3.34"
3931source = "registry+https://github.com/rust-lang/crates.io-index"
3932checksum = "031b47cf1a3c6cc8bc2fc76cd437f521619387907d469316e7c0bc278f1f5432"
3933dependencies = [
3934 "futures-core",
3935 "futures-task",
3936 "futures-util",
3937]
3938
3939[[package]]
3940name = "futures-intrusive"
3941version = "0.5.0"
3942source = "registry+https://github.com/rust-lang/crates.io-index"
3943checksum = "1d930c203dd0b6ff06e0201a4a2fe9149b43c684fd4420555b26d21b1a02956f"
3944dependencies = [
3945 "futures-core",
3946 "lock_api",
3947 "parking_lot",
3948]
3949
3950[[package]]
3951name = "futures-io"
3952version = "0.3.34"
3953source = "registry+https://github.com/rust-lang/crates.io-index"
3954checksum = "53c0fa8157de1303bfffdaa1cc2a673bfffb60102f76b0ef4441659124373fed"
3955
3956[[package]]
3957name = "futures-lite"
3958version = "2.6.1"
3959source = "registry+https://github.com/rust-lang/crates.io-index"
3960checksum = "f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad"
3961dependencies = [
3962 "futures-core",
3963 "pin-project-lite",
3964]
3965
3966[[package]]
3967name = "futures-macro"
3968version = "0.3.34"
3969source = "registry+https://github.com/rust-lang/crates.io-index"
3970checksum = "9fb9654ba8355388abeb8dcb4fc62f511300867002afc858860463bdd9fe0c44"
3971dependencies = [
3972 "proc-macro2",
3973 "quote",
3974 "syn 3.0.3",
3975]
3976
3977[[package]]
3978name = "futures-sink"
3979version = "0.3.34"
3980source = "registry+https://github.com/rust-lang/crates.io-index"
3981checksum = "1944426bf7d03f1d14f708785e4b33efd750b36d48a157b836b3efc15ede8e1d"
3982
3983[[package]]
3984name = "futures-task"
3985version = "0.3.34"
3986source = "registry+https://github.com/rust-lang/crates.io-index"
3987checksum = "cd417de3d1d015fc3bfd2b1ea46dfc7bab72ef86f1cc7cc9c78e728b34a6d1fd"
3988
3989[[package]]
3990name = "futures-timer"
3991version = "3.0.4"
3992source = "registry+https://github.com/rust-lang/crates.io-index"
3993checksum = "af43fadb8a98512d547e37b4e92e0ced13e205c061b87b4623eff01d918d6968"
3994dependencies = [
3995 "gloo-timers",
3996 "send_wrapper",
3997]
3998
3999[[package]]
4000name = "futures-util"
4001version = "0.3.34"
4002source = "registry+https://github.com/rust-lang/crates.io-index"
4003checksum = "0d50a92467f8ba5dd6e3ee5d4bd04d73ab2e4e1c44474a0674821dfce14b79bc"
4004dependencies = [
4005 "futures-channel",
4006 "futures-core",
4007 "futures-io",
4008 "futures-macro",
4009 "futures-sink",
4010 "futures-task",
4011 "memchr",
4012 "pin-project-lite",
4013 "slab",
4014]
4015
4016[[package]]
4017name = "generator"
4018version = "0.8.9"
4019source = "registry+https://github.com/rust-lang/crates.io-index"
4020checksum = "b3b854b0e584ead1a33f18b2fcad7cf7be18b3875c78816b753639aa501513ae"
4021dependencies = [
4022 "cc",
4023 "cfg-if",
4024 "libc",
4025 "log 0.4.33",
4026 "rustversion",
4027 "windows-link",
4028 "windows-result",
4029]
4030
4031[[package]]
4032name = "generic-array"
4033version = "0.14.9"
4034source = "registry+https://github.com/rust-lang/crates.io-index"
4035checksum = "4bb6743198531e02858aeaea5398fcc883e71851fcbcb5a2f773e2fb6cb1edf2"
4036dependencies = [
4037 "typenum",
4038 "version_check 0.9.5",
4039 "zeroize",
4040]
4041
4042[[package]]
4043name = "generic-array"
4044version = "1.4.5"
4045source = "registry+https://github.com/rust-lang/crates.io-index"
4046checksum = "337d46834ee672ab3e48caca2cb0c78cc174fb12b3a68d0d88f99a0519a5e36e"
4047dependencies = [
4048 "generic-array 0.14.9",
4049 "rustversion",
4050 "typenum",
4051]
4052
4053[[package]]
4054name = "getrandom"
4055version = "0.1.16"
4056source = "registry+https://github.com/rust-lang/crates.io-index"
4057checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce"
4058dependencies = [
4059 "cfg-if",
4060 "libc",
4061 "wasi 0.9.0+wasi-snapshot-preview1",
4062]
4063
4064[[package]]
4065name = "getrandom"
4066version = "0.2.17"
4067source = "registry+https://github.com/rust-lang/crates.io-index"
4068checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
4069dependencies = [
4070 "cfg-if",
4071 "js-sys",
4072 "libc",
4073 "wasi 0.11.1+wasi-snapshot-preview1",
4074 "wasm-bindgen",
4075]
4076
4077[[package]]
4078name = "getrandom"
4079version = "0.3.4"
4080source = "registry+https://github.com/rust-lang/crates.io-index"
4081checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
4082dependencies = [
4083 "cfg-if",
4084 "libc",
4085 "r-efi 5.3.0",
4086 "wasip2",
2563 "cfg-if",
2564 "libc",
2565 "r-efi 5.3.0",
2566 "wasip2",
40872567]
40882568
40892569[[package]]
@@ -4120,16 +2600,6 @@
41202600]
41212601
41222602[[package]]
4123name = "gif"
4124version = "0.14.2"
4125source = "registry+https://github.com/rust-lang/crates.io-index"
4126checksum = "ee8cfcc411d9adbbaba82fb72661cc1bcca13e8bba98b364e62b2dba8f960159"
4127dependencies = [
4128 "color_quant",
4129 "weezl",
4130]
4131
4132[[package]]
41332603name = "git"
41342604version = "1.0.0"
41352605dependencies = [
@@ -5133,12 +3603,6 @@
51333603]
51343604
51353605[[package]]
5136name = "glob"
5137version = "0.3.4"
5138source = "registry+https://github.com/rust-lang/crates.io-index"
5139checksum = "e4eba85ea1d0a966a983acd07deee566e67395d2d96b6fb39e62b5a833f1eb0b"
5140
5141[[package]]
51423606name = "globset"
51433607version = "0.4.20"
51443608source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -5152,18 +3616,6 @@
51523616]
51533617
51543618[[package]]
5155name = "gloo-timers"
5156version = "0.4.0"
5157source = "registry+https://github.com/rust-lang/crates.io-index"
5158checksum = "482ce8a491a501da4cd806bd190275363d674f2845005c6ddbd5d3e1dd54495d"
5159dependencies = [
5160 "futures-channel",
5161 "futures-core",
5162 "js-sys",
5163 "wasm-bindgen",
5164]
5165
5166[[package]]
51673619name = "group"
51683620version = "0.13.0"
51693621source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -5197,26 +3649,7 @@
51973649 "futures-sink",
51983650 "futures-util",
51993651 "http 0.2.12",
5200 "indexmap 2.14.0",
5201 "slab",
5202 "tokio",
5203 "tokio-util",
5204 "tracing",
5205]
5206
5207[[package]]
5208name = "h2"
5209version = "0.4.19"
5210source = "registry+https://github.com/rust-lang/crates.io-index"
5211checksum = "ef8e5e5a340588f4452631496976cf8636d4a7ecf600239fdc27615d2530bc16"
5212dependencies = [
5213 "atomic-waker",
5214 "bytes",
5215 "fnv",
5216 "futures-core",
5217 "futures-sink",
5218 "http 1.5.0",
5219 "indexmap 2.14.0",
3652 "indexmap",
52203653 "slab",
52213654 "tokio",
52223655 "tokio-util",
@@ -5277,22 +3710,13 @@
52773710
52783711[[package]]
52793712name = "hashbrown"
5280version = "0.15.5"
5281source = "registry+https://github.com/rust-lang/crates.io-index"
5282checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
5283dependencies = [
5284 "foldhash 0.1.5",
5285]
5286
5287[[package]]
5288name = "hashbrown"
52893713version = "0.16.1"
52903714source = "registry+https://github.com/rust-lang/crates.io-index"
52913715checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
52923716dependencies = [
52933717 "allocator-api2",
52943718 "equivalent",
5295 "foldhash 0.2.0",
3719 "foldhash",
52963720]
52973721
52983722[[package]]
@@ -5303,7 +3727,7 @@
53033727dependencies = [
53043728 "allocator-api2",
53053729 "equivalent",
5306 "foldhash 0.2.0",
3730 "foldhash",
53073731]
53083732
53093733[[package]]
@@ -5356,26 +3780,6 @@
53563780checksum = "e712f64ec3850b98572bffac52e2c6f282b29fe6c5fa6d42334b30be438d95c1"
53573781
53583782[[package]]
5359name = "hf-hub"
5360version = "0.4.3"
5361source = "registry+https://github.com/rust-lang/crates.io-index"
5362checksum = "629d8f3bbeda9d148036d6b0de0a3ab947abd08ce90626327fc3547a49d59d97"
5363dependencies = [
5364 "dirs 6.0.0",
5365 "http 1.5.0",
5366 "indicatif",
5367 "libc",
5368 "log 0.4.33",
5369 "rand 0.9.5",
5370 "reqwest 0.12.28",
5371 "serde",
5372 "serde_json",
5373 "thiserror 2.0.20",
5374 "ureq",
5375 "windows-sys 0.60.2",
5376]
5377
5378[[package]]
53793783name = "hkdf"
53803784version = "0.13.0"
53813785source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -5476,12 +3880,6 @@
54763880checksum = "eaec953f16e5bcf6b8a3cb3aa959b17e5577dbd2693e94554c462c08be22624b"
54773881
54783882[[package]]
5479name = "humantime"
5480version = "2.4.0"
5481source = "registry+https://github.com/rust-lang/crates.io-index"
5482checksum = "15cdd26707701c53297e2fa6afb323d55fbc1d0810c3aec078ae3ef0424c3c15"
5483
5484[[package]]
54853883name = "hybrid-array"
54863884version = "0.4.14"
54873885source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -5522,7 +3920,7 @@
55223920 "futures-channel",
55233921 "futures-core",
55243922 "futures-util",
5525 "h2 0.3.27",
3923 "h2",
55263924 "http 0.2.12",
55273925 "http-body 0.4.6",
55283926 "httparse",
@@ -5546,7 +3944,6 @@
55463944 "bytes",
55473945 "futures-channel",
55483946 "futures-core",
5549 "h2 0.4.19",
55503947 "http 1.5.0",
55513948 "http-body 1.1.0",
55523949 "httparse",
@@ -5579,11 +3976,10 @@
55793976 "hyper 1.11.0",
55803977 "hyper-util",
55813978 "rustls",
5582 "rustls-native-certs",
55833979 "tokio",
55843980 "tokio-rustls",
55853981 "tower-service",
5586 "webpki-roots 1.0.9",
3982 "webpki-roots",
55873983]
55883984
55893985[[package]]
@@ -5617,20 +4013,9 @@
56174013 "percent-encoding 2.3.2",
56184014 "pin-project-lite",
56194015 "socket2 0.6.5",
5620 "system-configuration",
56214016 "tokio",
56224017 "tower-service",
56234018 "tracing",
5624 "windows-registry",
5625]
5626
5627[[package]]
5628name = "hyperloglogplus"
5629version = "0.4.1"
5630source = "registry+https://github.com/rust-lang/crates.io-index"
5631checksum = "621debdf94dcac33e50475fdd76d34d5ea9c0362a834b9db08c3024696c1fbe3"
5632dependencies = [
5633 "serde",
56344019]
56354020
56364021[[package]]
@@ -5682,1423 +4067,669 @@
56824067]
56834068
56844069[[package]]
5685name = "icu_calendar"
5686version = "2.3.0"
5687source = "registry+https://github.com/rust-lang/crates.io-index"
5688checksum = "58655df2f728e46e4eee80bddebefacf52ec3e77cdb925014b47c5a5905eb55c"
5689dependencies = [
5690 "calendrical_calculations",
5691 "displaydoc",
5692 "icu_calendar_data",
5693 "icu_locale_core",
5694 "icu_locale_fallback",
5695 "icu_provider",
5696 "ixdtf",
5697 "serde",
5698 "tinystr",
5699 "zerovec",
5700]
5701
5702[[package]]
5703name = "icu_calendar_data"
5704version = "2.3.0"
5705source = "registry+https://github.com/rust-lang/crates.io-index"
5706checksum = "dc00caaa3fb3201ff7a18aa458e8c3ab042b9da154cfdf948bdde3936c31c36e"
5707
5708[[package]]
5709name = "icu_casemap"
5710version = "2.3.0"
5711source = "registry+https://github.com/rust-lang/crates.io-index"
5712checksum = "f2edfd120d8445de853cf53a1abec916f638f933a70a6f4bf8f7e2d7b7f884e9"
5713dependencies = [
5714 "icu_casemap_data",
5715 "icu_collections",
5716 "icu_locale_core",
5717 "icu_properties",
5718 "icu_provider",
5719 "potential_utf",
5720 "writeable",
5721 "zerovec",
5722]
5723
5724[[package]]
5725name = "icu_casemap_data"
5726version = "2.3.0"
5727source = "registry+https://github.com/rust-lang/crates.io-index"
5728checksum = "059fcda0fc8d33effc6633a8cf0d8a3c17caf7d7c91918fba9918744f501e4e8"
5729
5730[[package]]
5731name = "icu_collator"
5732version = "2.3.0"
5733source = "registry+https://github.com/rust-lang/crates.io-index"
5734checksum = "59eea194d189ca897bcb960fd2130f9e7d53998460d4d32e85a60b10d5507cf4"
5735dependencies = [
5736 "icu_collator_data",
5737 "icu_collections",
5738 "icu_locale_core",
5739 "icu_locale_fallback",
5740 "icu_normalizer",
5741 "icu_properties",
5742 "icu_provider",
5743 "smallvec",
5744 "utf16_iter",
5745 "utf8_iter",
5746 "zerovec",
5747]
5748
5749[[package]]
5750name = "icu_collator_data"
5751version = "2.3.0"
5752source = "registry+https://github.com/rust-lang/crates.io-index"
5753checksum = "f7d7e54efdddeb1208c08dd5d32b53a879ac00d2d3d051b2255fd26821d16368"
5754
5755[[package]]
5756name = "icu_collections"
5757version = "2.3.0"
5758source = "registry+https://github.com/rust-lang/crates.io-index"
5759checksum = "fa68d21081c4a05d5a901a1c62add574c77048b6a1c67be3b50ce0b60d4ca513"
5760dependencies = [
5761 "displaydoc",
5762 "potential_utf",
5763 "serde",
5764 "utf8_iter",
5765 "yoke",
5766 "zerofrom",
5767 "zerovec",
5768]
5769
5770[[package]]
5771name = "icu_datetime"
5772version = "2.3.0"
5773source = "registry+https://github.com/rust-lang/crates.io-index"
5774checksum = "c44df99c4c5297b05653d1a1629f13bdc9fd4044acfbbaf30b15194a1eed4cd6"
5775dependencies = [
5776 "displaydoc",
5777 "fixed_decimal",
5778 "icu_calendar",
5779 "icu_datetime_data",
5780 "icu_decimal",
5781 "icu_locale_core",
5782 "icu_locale_fallback",
5783 "icu_pattern",
5784 "icu_plurals",
5785 "icu_provider",
5786 "icu_time",
5787 "potential_utf",
5788 "tinystr",
5789 "writeable",
5790 "zerovec",
5791]
5792
5793[[package]]
5794name = "icu_datetime_data"
5795version = "2.3.0"
5796source = "registry+https://github.com/rust-lang/crates.io-index"
5797checksum = "8bb5555f6e4b42233f58564351ce16d73e9e6ebfce6bdcf29875d0cfc554d6a8"
5798
5799[[package]]
5800name = "icu_decimal"
5801version = "2.3.0"
5802source = "registry+https://github.com/rust-lang/crates.io-index"
5803checksum = "9eb8f655bba2d0c0459e43a5b0e6cd3cd388109898fb3d85d048165e8b0abd08"
5804dependencies = [
5805 "displaydoc",
5806 "fixed_decimal",
5807 "icu_decimal_data",
5808 "icu_locale_core",
5809 "icu_locale_fallback",
5810 "icu_pattern",
5811 "icu_plurals",
5812 "icu_provider",
5813 "serde",
5814 "writeable",
5815 "zerovec",
5816]
5817
5818[[package]]
5819name = "icu_decimal_data"
5820version = "2.3.0"
5821source = "registry+https://github.com/rust-lang/crates.io-index"
5822checksum = "e4c887fc7d4c297cf3f9436864af9e3dba7f8be9415a6c2a7f392f3b1636298c"
5823
5824[[package]]
5825name = "icu_experimental"
5826version = "0.6.0"
5827source = "registry+https://github.com/rust-lang/crates.io-index"
5828checksum = "7c09609ad18e249b97a0afa20e19502c4d11ab039e6e35f5ecf48bebd4eedd7e"
5829dependencies = [
5830 "displaydoc",
5831 "either",
5832 "fixed_decimal",
5833 "icu_casemap",
5834 "icu_collections",
5835 "icu_decimal",
5836 "icu_experimental_data",
5837 "icu_list",
5838 "icu_locale",
5839 "icu_locale_core",
5840 "icu_locale_fallback",
5841 "icu_normalizer",
5842 "icu_pattern",
5843 "icu_plurals",
5844 "icu_properties",
5845 "icu_provider",
5846 "litemap",
5847 "num-bigint 0.4.8",
5848 "num-rational",
5849 "num-traits",
5850 "potential_utf",
5851 "smallvec",
5852 "tinystr",
5853 "writeable",
5854 "zerotrie",
5855 "zerovec",
5856]
5857
5858[[package]]
5859name = "icu_experimental_data"
5860version = "0.6.0"
5861source = "registry+https://github.com/rust-lang/crates.io-index"
5862checksum = "377481a8935d6774f410424d79a6dc8a09d9bd8def9560cff17abe755a246280"
5863
5864[[package]]
5865name = "icu_list"
5866version = "2.3.0"
5867source = "registry+https://github.com/rust-lang/crates.io-index"
5868checksum = "5a5c625125085fac4bf9ad111888a90c6ab9dc7bcaec392ca79cab417f46e3fb"
5869dependencies = [
5870 "icu_list_data",
5871 "icu_locale_fallback",
5872 "icu_provider",
5873 "regex-automata",
5874 "serde",
5875 "writeable",
5876 "zerovec",
5877]
5878
5879[[package]]
5880name = "icu_list_data"
5881version = "2.3.0"
5882source = "registry+https://github.com/rust-lang/crates.io-index"
5883checksum = "4ffef91ee351bd195a803115615a034dfb9f02bb48850980548c31cb78568a91"
5884
5885[[package]]
5886name = "icu_locale"
4070name = "icu_calendar"
58874071version = "2.3.0"
58884072source = "registry+https://github.com/rust-lang/crates.io-index"
5889checksum = "250ec6d4ac288584d1d0ba29dbfad7737635b7b0e822441f4026a523e3fdb147"
4073checksum = "58655df2f728e46e4eee80bddebefacf52ec3e77cdb925014b47c5a5905eb55c"
58904074dependencies = [
5891 "icu_collections",
4075 "calendrical_calculations",
4076 "displaydoc",
4077 "icu_calendar_data",
58924078 "icu_locale_core",
5893 "icu_locale_data",
58944079 "icu_locale_fallback",
58954080 "icu_provider",
5896 "tinystr",
5897 "zerovec",
5898]
5899
5900[[package]]
5901name = "icu_locale_core"
5902version = "2.3.0"
5903source = "registry+https://github.com/rust-lang/crates.io-index"
5904checksum = "d56e28588da92eee5c3201a6eff33fabdd49b62269c8938d4ff050ce4d900deb"
5905dependencies = [
5906 "displaydoc",
5907 "litemap",
4081 "ixdtf",
59084082 "serde",
59094083 "tinystr",
5910 "writeable",
59114084 "zerovec",
59124085]
59134086
59144087[[package]]
5915name = "icu_locale_data"
4088name = "icu_calendar_data"
59164089version = "2.3.0"
59174090source = "registry+https://github.com/rust-lang/crates.io-index"
5918checksum = "d37d91460e362a5cf58907cd7ce871411775ee6294e49a5cc8e6cec16dfa75ea"
4091checksum = "dc00caaa3fb3201ff7a18aa458e8c3ab042b9da154cfdf948bdde3936c31c36e"
59194092
59204093[[package]]
5921name = "icu_locale_fallback"
4094name = "icu_casemap"
59224095version = "2.3.0"
59234096source = "registry+https://github.com/rust-lang/crates.io-index"
5924checksum = "251af8e57c9400e3eb58242fe5b8b1152b2a64fdf4cf632f923c38ccee6f2fa9"
4097checksum = "f2edfd120d8445de853cf53a1abec916f638f933a70a6f4bf8f7e2d7b7f884e9"
59254098dependencies = [
4099 "icu_casemap_data",
4100 "icu_collections",
59264101 "icu_locale_core",
5927 "icu_locale_fallback_data",
4102 "icu_properties",
59284103 "icu_provider",
59294104 "potential_utf",
5930 "tinystr",
4105 "writeable",
59314106 "zerovec",
59324107]
59334108
59344109[[package]]
5935name = "icu_locale_fallback_data"
4110name = "icu_casemap_data"
59364111version = "2.3.0"
59374112source = "registry+https://github.com/rust-lang/crates.io-index"
5938checksum = "decf2a22ec8fa68f1a0c1129a3f8583f8f8bc24e8b9ccbe98ead99f62a4dc3a8"
4113checksum = "059fcda0fc8d33effc6633a8cf0d8a3c17caf7d7c91918fba9918744f501e4e8"
59394114
59404115[[package]]
5941name = "icu_normalizer"
4116name = "icu_collator"
59424117version = "2.3.0"
59434118source = "registry+https://github.com/rust-lang/crates.io-index"
5944checksum = "12f9cf5f235641ed274641dd81c3f28d870e276763d0797aeeab72317b1c646f"
4119checksum = "59eea194d189ca897bcb960fd2130f9e7d53998460d4d32e85a60b10d5507cf4"
59454120dependencies = [
4121 "icu_collator_data",
59464122 "icu_collections",
5947 "icu_normalizer_data",
4123 "icu_locale_core",
4124 "icu_locale_fallback",
4125 "icu_normalizer",
59484126 "icu_properties",
59494127 "icu_provider",
59504128 "smallvec",
59514129 "utf16_iter",
59524130 "utf8_iter",
5953 "write16",
59544131 "zerovec",
59554132]
59564133
59574134[[package]]
5958name = "icu_normalizer_data"
4135name = "icu_collator_data"
59594136version = "2.3.0"
59604137source = "registry+https://github.com/rust-lang/crates.io-index"
5961checksum = "1563da1ed3e0b3bf3d74c9b85917ac9c56464d2f57242270c09c9e752f8021a0"
4138checksum = "f7d7e54efdddeb1208c08dd5d32b53a879ac00d2d3d051b2255fd26821d16368"
59624139
59634140[[package]]
5964name = "icu_pattern"
5965version = "0.5.0"
4141name = "icu_collections"
4142version = "2.3.0"
59664143source = "registry+https://github.com/rust-lang/crates.io-index"
5967checksum = "2b3db611446bd92c246b03e4aa0bafa71ddb194af431ddbb42b9d70e4bfce1a0"
4144checksum = "fa68d21081c4a05d5a901a1c62add574c77048b6a1c67be3b50ce0b60d4ca513"
59684145dependencies = [
59694146 "displaydoc",
5970 "either",
4147 "potential_utf",
59714148 "serde",
5972 "writeable",
4149 "utf8_iter",
59734150 "yoke",
4151 "zerofrom",
59744152 "zerovec",
59754153]
59764154
59774155[[package]]
5978name = "icu_plurals"
4156name = "icu_datetime"
59794157version = "2.3.0"
59804158source = "registry+https://github.com/rust-lang/crates.io-index"
5981checksum = "e475e6766ef87b1d3c1f97be6363995b0bfaeddbc789671615df598a97ff0593"
4159checksum = "c44df99c4c5297b05653d1a1629f13bdc9fd4044acfbbaf30b15194a1eed4cd6"
59824160dependencies = [
4161 "displaydoc",
59834162 "fixed_decimal",
4163 "icu_calendar",
4164 "icu_datetime_data",
4165 "icu_decimal",
4166 "icu_locale_core",
59844167 "icu_locale_fallback",
5985 "icu_plurals_data",
4168 "icu_pattern",
4169 "icu_plurals",
59864170 "icu_provider",
4171 "icu_time",
4172 "potential_utf",
4173 "tinystr",
4174 "writeable",
59874175 "zerovec",
59884176]
59894177
59904178[[package]]
5991name = "icu_plurals_data"
4179name = "icu_datetime_data"
59924180version = "2.3.0"
59934181source = "registry+https://github.com/rust-lang/crates.io-index"
5994checksum = "1251aa39a95e1333888e499b1263e1c196447a28948acf5bdabd82c046f153bf"
4182checksum = "8bb5555f6e4b42233f58564351ce16d73e9e6ebfce6bdcf29875d0cfc554d6a8"
59954183
59964184[[package]]
5997name = "icu_properties"
4185name = "icu_decimal"
59984186version = "2.3.0"
59994187source = "registry+https://github.com/rust-lang/crates.io-index"
6000checksum = "7e7ca276ad3145661a65914e6daf131ca5120cd3dcee8f8f3214b8875184a148"
4188checksum = "9eb8f655bba2d0c0459e43a5b0e6cd3cd388109898fb3d85d048165e8b0abd08"
60014189dependencies = [
60024190 "displaydoc",
6003 "icu_collections",
4191 "fixed_decimal",
4192 "icu_decimal_data",
60044193 "icu_locale_core",
6005 "icu_properties_data",
4194 "icu_locale_fallback",
4195 "icu_pattern",
4196 "icu_plurals",
60064197 "icu_provider",
60074198 "serde",
6008 "zerotrie",
4199 "writeable",
60094200 "zerovec",
60104201]
60114202
60124203[[package]]
6013name = "icu_properties_data"
4204name = "icu_decimal_data"
60144205version = "2.3.0"
60154206source = "registry+https://github.com/rust-lang/crates.io-index"
6016checksum = "e590f038c1464a96894fd6d10127e90a8be4509f56ff7ecef851b15cee0b7caa"
4207checksum = "e4c887fc7d4c297cf3f9436864af9e3dba7f8be9415a6c2a7f392f3b1636298c"
60174208
60184209[[package]]
6019name = "icu_provider"
6020version = "2.3.0"
4210name = "icu_experimental"
4211version = "0.6.0"
60214212source = "registry+https://github.com/rust-lang/crates.io-index"
6022checksum = "92a7ed671a6aad807a8651a2e1782a6598fda9ce5185dd8158549e95a91c6428"
4213checksum = "7c09609ad18e249b97a0afa20e19502c4d11ab039e6e35f5ecf48bebd4eedd7e"
60234214dependencies = [
60244215 "displaydoc",
4216 "either",
4217 "fixed_decimal",
4218 "icu_casemap",
4219 "icu_collections",
4220 "icu_decimal",
4221 "icu_experimental_data",
4222 "icu_list",
4223 "icu_locale",
60254224 "icu_locale_core",
6026 "serde",
6027 "stable_deref_trait",
6028 "writeable",
6029 "yoke",
6030 "zerofrom",
6031 "zerotrie",
6032 "zerovec",
6033]
6034
6035[[package]]
6036name = "icu_segmenter"
6037version = "2.3.0"
6038source = "registry+https://github.com/rust-lang/crates.io-index"
6039checksum = "82d07aafccd67af15d02512a6adf5896fbc5ed00f2e99b471d2efa14016db3db"
6040dependencies = [
6041 "core_maths",
6042 "icu_collections",
60434225 "icu_locale_fallback",
4226 "icu_normalizer",
4227 "icu_pattern",
4228 "icu_plurals",
4229 "icu_properties",
60444230 "icu_provider",
6045 "icu_segmenter_data",
4231 "litemap",
4232 "num-bigint 0.4.8",
4233 "num-rational",
4234 "num-traits",
60464235 "potential_utf",
60474236 "smallvec",
6048 "utf8_iter",
6049 "zerovec",
6050]
6051
6052[[package]]
6053name = "icu_segmenter_data"
6054version = "2.3.0"
6055source = "registry+https://github.com/rust-lang/crates.io-index"
6056checksum = "ae293c039020f9ec10710af98d29ce6aa2051486638b49c9a6409f3b4a9e98ad"
6057
6058[[package]]
6059name = "icu_time"
6060version = "2.3.0"
6061source = "registry+https://github.com/rust-lang/crates.io-index"
6062checksum = "af37e1c3b9f3ab564b619fdf4b22de169f6381eb0f7048e3ca454290c438126b"
6063dependencies = [
6064 "calendrical_calculations",
6065 "displaydoc",
6066 "icu_calendar",
6067 "icu_locale_core",
6068 "icu_provider",
6069 "icu_time_data",
6070 "ixdtf",
6071 "serde",
4237 "tinystr",
4238 "writeable",
60724239 "zerotrie",
60734240 "zerovec",
60744241]
60754242
60764243[[package]]
6077name = "icu_time_data"
6078version = "2.3.0"
6079source = "registry+https://github.com/rust-lang/crates.io-index"
6080checksum = "005ff86fa5851a77fc0a977b72d717f777bd9230415a247219d7898aefb1517a"
6081
6082[[package]]
6083name = "ident_case"
6084version = "1.0.1"
6085source = "registry+https://github.com/rust-lang/crates.io-index"
6086checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
6087
6088[[package]]
6089name = "idna"
6090version = "0.1.5"
6091source = "registry+https://github.com/rust-lang/crates.io-index"
6092checksum = "38f09e0f0b1fb55fdee1f17470ad800da77af5186a1a76c026b679358b7e844e"
6093dependencies = [
6094 "matches",
6095 "unicode-bidi",
6096 "unicode-normalization",
6097]
6098
6099[[package]]
6100name = "idna"
6101version = "1.1.0"
6102source = "registry+https://github.com/rust-lang/crates.io-index"
6103checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
6104dependencies = [
6105 "idna_adapter",
6106 "smallvec",
6107 "utf8_iter",
6108]
6109
6110[[package]]
6111name = "idna_adapter"
6112version = "1.2.2"
6113source = "registry+https://github.com/rust-lang/crates.io-index"
6114checksum = "cb68373c0d6620ef8105e855e7745e18b0d00d3bdb07fb532e434244cdb9a714"
6115dependencies = [
6116 "icu_normalizer",
6117 "icu_properties",
6118]
6119
6120[[package]]
6121name = "image"
6122version = "0.25.10"
6123source = "registry+https://github.com/rust-lang/crates.io-index"
6124checksum = "85ab80394333c02fe689eaf900ab500fbd0c2213da414687ebf995a65d5a6104"
6125dependencies = [
6126 "bytemuck",
6127 "byteorder-lite",
6128 "color_quant",
6129 "exr",
6130 "gif",
6131 "image-webp",
6132 "moxcms",
6133 "num-traits",
6134 "png",
6135 "qoi",
6136 "ravif",
6137 "rayon",
6138 "rgb",
6139 "tiff",
6140 "zune-core",
6141 "zune-jpeg",
6142]
6143
6144[[package]]
6145name = "image-webp"
6146version = "0.2.4"
6147source = "registry+https://github.com/rust-lang/crates.io-index"
6148checksum = "525e9ff3e1a4be2fbea1fdf0e98686a6d98b4d8f937e1bf7402245af1909e8c3"
6149dependencies = [
6150 "byteorder-lite",
6151 "quick-error",
6152]
6153
6154[[package]]
6155name = "imgref"
6156version = "1.12.3"
6157source = "registry+https://github.com/rust-lang/crates.io-index"
6158checksum = "6e44b0a4eaa4c82f441d50a963f2d5f05a787240aeee097597033e72accfd22f"
6159
6160[[package]]
6161name = "indexmap"
6162version = "1.9.3"
6163source = "registry+https://github.com/rust-lang/crates.io-index"
6164checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
6165dependencies = [
6166 "autocfg",
6167 "hashbrown 0.12.3",
6168 "serde",
6169]
6170
6171[[package]]
6172name = "indexmap"
6173version = "2.14.0"
6174source = "registry+https://github.com/rust-lang/crates.io-index"
6175checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"
6176dependencies = [
6177 "equivalent",
6178 "hashbrown 0.17.1",
6179 "serde",
6180 "serde_core",
6181]
6182
6183[[package]]
6184name = "indicatif"
6185version = "0.17.11"
6186source = "registry+https://github.com/rust-lang/crates.io-index"
6187checksum = "183b3088984b400f4cfac3620d5e076c84da5364016b4f49473de574b2586235"
6188dependencies = [
6189 "console",
6190 "number_prefix",
6191 "portable-atomic",
6192 "unicode-width",
6193 "web-time",
6194]
6195
6196[[package]]
6197name = "inlinable_string"
6198version = "0.1.15"
4244name = "icu_experimental_data"
4245version = "0.6.0"
61994246source = "registry+https://github.com/rust-lang/crates.io-index"
6200checksum = "c8fae54786f62fb2918dcfae3d568594e50eb9b5c25bf04371af6fe7516452fb"
4247checksum = "377481a8935d6774f410424d79a6dc8a09d9bd8def9560cff17abe755a246280"
62014248
62024249[[package]]
6203name = "inout"
6204version = "0.1.4"
4250name = "icu_list"
4251version = "2.3.0"
62054252source = "registry+https://github.com/rust-lang/crates.io-index"
6206checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
4253checksum = "5a5c625125085fac4bf9ad111888a90c6ab9dc7bcaec392ca79cab417f46e3fb"
62074254dependencies = [
6208 "generic-array 0.14.9",
4255 "icu_list_data",
4256 "icu_locale_fallback",
4257 "icu_provider",
4258 "regex-automata",
4259 "serde",
4260 "writeable",
4261 "zerovec",
62094262]
62104263
62114264[[package]]
6212name = "inout"
6213version = "0.2.2"
4265name = "icu_list_data"
4266version = "2.3.0"
62144267source = "registry+https://github.com/rust-lang/crates.io-index"
6215checksum = "4250ce6452e92010fdf7268ccc5d14faa80bb12fc741938534c58f16804e03c7"
6216dependencies = [
6217 "block-padding",
6218 "hybrid-array",
6219]
4268checksum = "4ffef91ee351bd195a803115615a034dfb9f02bb48850980548c31cb78568a91"
62204269
62214270[[package]]
6222name = "internal-russh-num-bigint"
6223version = "0.5.0"
4271name = "icu_locale"
4272version = "2.3.0"
62244273source = "registry+https://github.com/rust-lang/crates.io-index"
6225checksum = "ae8e22120c32fb4d19ec55fba35015f57095cd95a2e3b732e44457f5915b2ee8"
4274checksum = "250ec6d4ac288584d1d0ba29dbfad7737635b7b0e822441f4026a523e3fdb147"
62264275dependencies = [
6227 "num-integer",
6228 "num-traits",
6229 "rand 0.10.2",
6230 "rand_core 0.10.1",
4276 "icu_collections",
4277 "icu_locale_core",
4278 "icu_locale_data",
4279 "icu_locale_fallback",
4280 "icu_provider",
4281 "tinystr",
4282 "zerovec",
62314283]
62324284
62334285[[package]]
6234name = "interpolate_name"
6235version = "0.2.4"
4286name = "icu_locale_core"
4287version = "2.3.0"
62364288source = "registry+https://github.com/rust-lang/crates.io-index"
6237checksum = "c34819042dc3d3971c46c2190835914dfbe0c3c13f61449b2997f4e9722dfa60"
4289checksum = "d56e28588da92eee5c3201a6eff33fabdd49b62269c8938d4ff050ce4d900deb"
62384290dependencies = [
6239 "proc-macro2",
6240 "quote",
6241 "syn 2.0.119",
4291 "displaydoc",
4292 "litemap",
4293 "serde",
4294 "tinystr",
4295 "writeable",
4296 "zerovec",
62424297]
62434298
62444299[[package]]
6245name = "inventory"
6246version = "0.3.24"
4300name = "icu_locale_data"
4301version = "2.3.0"
62474302source = "registry+https://github.com/rust-lang/crates.io-index"
6248checksum = "a4f0c30c76f2f4ccee3fe55a2435f691ca00c0e4bd87abe4f4a851b1d4dac39b"
6249dependencies = [
6250 "rustversion",
6251]
4303checksum = "d37d91460e362a5cf58907cd7ce871411775ee6294e49a5cc8e6cec16dfa75ea"
62524304
62534305[[package]]
6254name = "io-close"
6255version = "0.3.7"
4306name = "icu_locale_fallback"
4307version = "2.3.0"
62564308source = "registry+https://github.com/rust-lang/crates.io-index"
6257checksum = "9cadcf447f06744f8ce713d2d6239bb5bde2c357a452397a9ed90c625da390bc"
4309checksum = "251af8e57c9400e3eb58242fe5b8b1152b2a64fdf4cf632f923c38ccee6f2fa9"
62584310dependencies = [
6259 "libc",
6260 "winapi",
4311 "icu_locale_core",
4312 "icu_locale_fallback_data",
4313 "icu_provider",
4314 "potential_utf",
4315 "tinystr",
4316 "zerovec",
62614317]
62624318
62634319[[package]]
6264name = "io-uring"
6265version = "0.7.14"
4320name = "icu_locale_fallback_data"
4321version = "2.3.0"
62664322source = "registry+https://github.com/rust-lang/crates.io-index"
6267checksum = "d64d8ca234d152948ceaede1f419b6a83983a5ecccaac05fb337a809c96d3aa6"
6268dependencies = [
6269 "bitflags 2.13.1",
6270 "cfg-if",
6271 "libc",
6272]
4323checksum = "decf2a22ec8fa68f1a0c1129a3f8583f8f8bc24e8b9ccbe98ead99f62a4dc3a8"
62734324
62744325[[package]]
6275name = "ipnet"
6276version = "2.12.1"
4326name = "icu_normalizer"
4327version = "2.3.0"
62774328source = "registry+https://github.com/rust-lang/crates.io-index"
6278checksum = "6a756c3fac73139e83f14c2d742155dd2b78d3ee56597b419a0579b7bdd6dd78"
6279
6280[[package]]
6281name = "issues"
6282version = "1.0.0"
4329checksum = "12f9cf5f235641ed274641dd81c3f28d870e276763d0797aeeab72317b1c646f"
62834330dependencies = [
6284 "async-trait",
6285 "axum",
6286 "config",
6287 "email",
6288 "export",
6289 "models",
6290 "sea-orm",
6291 "serde",
6292 "serde_json",
6293 "session",
6294 "space",
6295 "time 0.3.55",
6296 "tracing",
6297 "utoipa",
6298 "uuid",
4331 "icu_collections",
4332 "icu_normalizer_data",
4333 "icu_properties",
4334 "icu_provider",
4335 "smallvec",
4336 "utf16_iter",
4337 "utf8_iter",
4338 "write16",
4339 "zerovec",
62994340]
63004341
63014342[[package]]
6302name = "itertools"
6303version = "0.13.0"
4343name = "icu_normalizer_data"
4344version = "2.3.0"
63044345source = "registry+https://github.com/rust-lang/crates.io-index"
6305checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
6306dependencies = [
6307 "either",
6308]
4346checksum = "1563da1ed3e0b3bf3d74c9b85917ac9c56464d2f57242270c09c9e752f8021a0"
63094347
63104348[[package]]
6311name = "itertools"
6312version = "0.14.0"
4349name = "icu_pattern"
4350version = "0.5.0"
63134351source = "registry+https://github.com/rust-lang/crates.io-index"
6314checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
4352checksum = "2b3db611446bd92c246b03e4aa0bafa71ddb194af431ddbb42b9d70e4bfce1a0"
63154353dependencies = [
4354 "displaydoc",
63164355 "either",
4356 "serde",
4357 "writeable",
4358 "yoke",
4359 "zerovec",
63174360]
63184361
63194362[[package]]
6320name = "itertools"
6321version = "0.15.0"
4363name = "icu_plurals"
4364version = "2.3.0"
63224365source = "registry+https://github.com/rust-lang/crates.io-index"
6323checksum = "8b4baf93f58d4425749ca49a51c50ebab072c5df6994d08fed93541c331481dc"
4366checksum = "e475e6766ef87b1d3c1f97be6363995b0bfaeddbc789671615df598a97ff0593"
63244367dependencies = [
6325 "either",
4368 "fixed_decimal",
4369 "icu_locale_fallback",
4370 "icu_plurals_data",
4371 "icu_provider",
4372 "zerovec",
63264373]
63274374
63284375[[package]]
6329name = "itoa"
6330version = "1.0.18"
4376name = "icu_plurals_data"
4377version = "2.3.0"
63314378source = "registry+https://github.com/rust-lang/crates.io-index"
6332checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
4379checksum = "1251aa39a95e1333888e499b1263e1c196447a28948acf5bdabd82c046f153bf"
63334380
63344381[[package]]
6335name = "ixdtf"
6336version = "0.6.6"
4382name = "icu_properties"
4383version = "2.3.0"
63374384source = "registry+https://github.com/rust-lang/crates.io-index"
6338checksum = "4d3667095d64c3ecffc96463a21157b04bf3e252f6e8d5750b20c02e33c194e3"
6339
6340[[package]]
6341name = "jieba-macros"
6342version = "0.9.0"
6343source = "registry+https://github.com/rust-lang/crates.io-index"
6344checksum = "a29cfc5dcd898604c6f80363411fa6b6b08e27d1d253d6225b9cb6702ea02fc0"
4385checksum = "7e7ca276ad3145661a65914e6daf131ca5120cd3dcee8f8f3214b8875184a148"
63454386dependencies = [
6346 "phf_codegen",
4387 "displaydoc",
4388 "icu_collections",
4389 "icu_locale_core",
4390 "icu_properties_data",
4391 "icu_provider",
4392 "serde",
4393 "zerotrie",
4394 "zerovec",
63474395]
63484396
63494397[[package]]
6350name = "jieba-rs"
6351version = "0.9.0"
4398name = "icu_properties_data"
4399version = "2.3.0"
63524400source = "registry+https://github.com/rust-lang/crates.io-index"
6353checksum = "3245d6e9d1d5facbd6a23848d6b67e3439738ccbb4fa5a3d65da315ba1a910a2"
6354dependencies = [
6355 "cedarwood",
6356 "jieba-macros",
6357 "phf 0.13.1",
6358 "regex",
6359 "rustc-hash",
6360]
4401checksum = "e590f038c1464a96894fd6d10127e90a8be4509f56ff7ecef851b15cee0b7caa"
63614402
63624403[[package]]
6363name = "jiff"
6364version = "0.2.35"
4404name = "icu_provider"
4405version = "2.3.0"
63654406source = "registry+https://github.com/rust-lang/crates.io-index"
6366checksum = "668b7183bd07af9a4885f5c35b0cc5c83c4607a913c16b7e17291832910d2dcc"
4407checksum = "92a7ed671a6aad807a8651a2e1782a6598fda9ce5185dd8158549e95a91c6428"
63674408dependencies = [
6368 "defmt",
6369 "jiff-core",
6370 "jiff-static",
6371 "jiff-tzdb-platform",
6372 "log 0.4.33",
6373 "portable-atomic",
6374 "portable-atomic-util",
6375 "serde_core",
6376 "windows-link",
4409 "displaydoc",
4410 "icu_locale_core",
4411 "serde",
4412 "stable_deref_trait",
4413 "writeable",
4414 "yoke",
4415 "zerofrom",
4416 "zerotrie",
4417 "zerovec",
63774418]
63784419
63794420[[package]]
6380name = "jiff-core"
6381version = "0.1.0"
4421name = "icu_segmenter"
4422version = "2.3.0"
63824423source = "registry+https://github.com/rust-lang/crates.io-index"
6383checksum = "7feca88439efe53da3754500c1851dedf3cb36c524dd5cf8225cc0794de95d09"
4424checksum = "82d07aafccd67af15d02512a6adf5896fbc5ed00f2e99b471d2efa14016db3db"
63844425dependencies = [
6385 "defmt",
6386]
6387
6388[[package]]
6389name = "jiff-static"
6390version = "0.2.35"
6391source = "registry+https://github.com/rust-lang/crates.io-index"
6392checksum = "3a69dcb3a21cfb32ce1cd056169337ca284af0766dd766e7878819b251a49204"
6393dependencies = [
6394 "jiff-core",
6395 "proc-macro2",
6396 "quote",
6397 "syn 2.0.119",
6398]
6399
6400[[package]]
6401name = "jiff-tzdb"
6402version = "0.1.8"
6403source = "registry+https://github.com/rust-lang/crates.io-index"
6404checksum = "142bd39932ad231f10513df9ab62661fead8719872150b7ad02a2df79f4e141e"
6405
6406[[package]]
6407name = "jiff-tzdb-platform"
6408version = "0.1.3"
6409source = "registry+https://github.com/rust-lang/crates.io-index"
6410checksum = "875a5a69ac2bab1a891711cf5eccbec1ce0341ea805560dcd90b7a2e925132e8"
6411dependencies = [
6412 "jiff-tzdb",
4426 "core_maths",
4427 "icu_collections",
4428 "icu_locale_fallback",
4429 "icu_provider",
4430 "icu_segmenter_data",
4431 "potential_utf",
4432 "smallvec",
4433 "utf8_iter",
4434 "zerovec",
64134435]
64144436
64154437[[package]]
6416name = "jni"
6417version = "0.22.4"
4438name = "icu_segmenter_data"
4439version = "2.3.0"
64184440source = "registry+https://github.com/rust-lang/crates.io-index"
6419checksum = "5efd9a482cf3a427f00d6b35f14332adc7902ce91efb778580e180ff90fa3498"
6420dependencies = [
6421 "cfg-if",
6422 "combine",
6423 "jni-macros",
6424 "jni-sys",
6425 "log 0.4.33",
6426 "simd_cesu8",
6427 "thiserror 2.0.20",
6428 "walkdir",
6429 "windows-link",
6430]
4441checksum = "ae293c039020f9ec10710af98d29ce6aa2051486638b49c9a6409f3b4a9e98ad"
64314442
64324443[[package]]
6433name = "jni-macros"
6434version = "0.22.4"
4444name = "icu_time"
4445version = "2.3.0"
64354446source = "registry+https://github.com/rust-lang/crates.io-index"
6436checksum = "a00109accc170f0bdb141fed3e393c565b6f5e072365c3bd58f5b062591560a3"
4447checksum = "af37e1c3b9f3ab564b619fdf4b22de169f6381eb0f7048e3ca454290c438126b"
64374448dependencies = [
6438 "proc-macro2",
6439 "quote",
6440 "rustc_version",
6441 "simd_cesu8",
6442 "syn 2.0.119",
4449 "calendrical_calculations",
4450 "displaydoc",
4451 "icu_calendar",
4452 "icu_locale_core",
4453 "icu_provider",
4454 "icu_time_data",
4455 "ixdtf",
4456 "serde",
4457 "zerotrie",
4458 "zerovec",
64434459]
64444460
64454461[[package]]
6446name = "jni-sys"
6447version = "0.4.1"
4462name = "icu_time_data"
4463version = "2.3.0"
64484464source = "registry+https://github.com/rust-lang/crates.io-index"
6449checksum = "c6377a88cb3910bee9b0fa88d4f42e1d2da8e79915598f65fb0c7ee14c878af2"
6450dependencies = [
6451 "jni-sys-macros",
6452]
4465checksum = "005ff86fa5851a77fc0a977b72d717f777bd9230415a247219d7898aefb1517a"
64534466
64544467[[package]]
6455name = "jni-sys-macros"
6456version = "0.4.1"
4468name = "ident_case"
4469version = "1.0.1"
64574470source = "registry+https://github.com/rust-lang/crates.io-index"
6458checksum = "38c0b942f458fe50cdac086d2f946512305e5631e720728f2a61aabcd47a6264"
6459dependencies = [
6460 "quote",
6461 "syn 2.0.119",
6462]
4471checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
64634472
64644473[[package]]
6465name = "jobserver"
6466version = "0.1.35"
4474name = "idna"
4475version = "0.1.5"
64674476source = "registry+https://github.com/rust-lang/crates.io-index"
6468checksum = "1c00acbd29eabad4a2392fa0e921c874934dbbf4194312ad20f04a0ed67a3cb3"
4477checksum = "38f09e0f0b1fb55fdee1f17470ad800da77af5186a1a76c026b679358b7e844e"
64694478dependencies = [
6470 "getrandom 0.4.3",
6471 "libc",
4479 "matches",
4480 "unicode-bidi",
4481 "unicode-normalization",
64724482]
64734483
64744484[[package]]
6475name = "js-sys"
6476version = "0.3.104"
4485name = "idna"
4486version = "1.1.0"
64774487source = "registry+https://github.com/rust-lang/crates.io-index"
6478checksum = "0e0c1080212aad755ea003d18543e8768dd432c48819efd73a7bf1e39b7a5a3a"
4488checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
64794489dependencies = [
6480 "cfg-if",
6481 "futures-util",
6482 "wasm-bindgen",
4490 "idna_adapter",
4491 "smallvec",
4492 "utf8_iter",
64834493]
64844494
64854495[[package]]
6486name = "jsonb"
6487version = "0.5.6"
4496name = "idna_adapter"
4497version = "1.2.2"
64884498source = "registry+https://github.com/rust-lang/crates.io-index"
6489checksum = "eb98fb29636087c40ad0d1274d9a30c0c1e83e03ae93f6e7e89247b37fcc6953"
4499checksum = "cb68373c0d6620ef8105e855e7745e18b0d00d3bdb07fb532e434244cdb9a714"
64904500dependencies = [
6491 "byteorder",
6492 "ethnum",
6493 "fast-float2",
6494 "itoa",
6495 "jiff",
6496 "nom 8.0.0",
6497 "num-traits",
6498 "ordered-float 5.5.0",
6499 "rand 0.9.5",
6500 "serde",
6501 "serde_json",
6502 "zmij",
4501 "icu_normalizer",
4502 "icu_properties",
65034503]
65044504
65054505[[package]]
6506name = "kanaria"
6507version = "0.2.0"
4506name = "indexmap"
4507version = "2.14.0"
65084508source = "registry+https://github.com/rust-lang/crates.io-index"
6509checksum = "c0f9d9652540055ac4fded998a73aca97d965899077ab1212587437da44196ff"
4509checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"
65104510dependencies = [
6511 "bitflags 1.3.2",
4511 "equivalent",
4512 "hashbrown 0.17.1",
4513 "serde",
4514 "serde_core",
65124515]
65134516
65144517[[package]]
6515name = "keccak"
6516version = "0.2.1"
4518name = "inlinable_string"
4519version = "0.1.15"
65174520source = "registry+https://github.com/rust-lang/crates.io-index"
6518checksum = "ffd9697dc4a9a62e2da93389f34400b77a28f0287711263cabb203b3ccb9c0e4"
6519dependencies = [
6520 "cfg-if",
6521 "cpufeatures 0.3.0",
6522]
4521checksum = "c8fae54786f62fb2918dcfae3d568594e50eb9b5c25bf04371af6fe7516452fb"
65234522
65244523[[package]]
6525name = "kem"
6526version = "0.3.0"
4524name = "inout"
4525version = "0.1.4"
65274526source = "registry+https://github.com/rust-lang/crates.io-index"
6528checksum = "01737161ba802849cfd486b5bd209d38ba4943494c249a8126005170c7621edd"
4527checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
65294528dependencies = [
6530 "crypto-common 0.2.2",
6531 "rand_core 0.10.1",
4529 "generic-array 0.14.9",
65324530]
65334531
65344532[[package]]
6535name = "lance"
6536version = "7.0.0"
4533name = "inout"
4534version = "0.2.2"
65374535source = "registry+https://github.com/rust-lang/crates.io-index"
6538checksum = "3944aca86f4c78f4da04af1c2bf33e664a2826b7af72972ad200d6b9de59019f"
4536checksum = "4250ce6452e92010fdf7268ccc5d14faa80bb12fc741938534c58f16804e03c7"
65394537dependencies = [
6540 "arc-swap",
6541 "arrow",
6542 "arrow-arith",
6543 "arrow-array",
6544 "arrow-buffer",
6545 "arrow-cast",
6546 "arrow-ipc",
6547 "arrow-ord",
6548 "arrow-row",
6549 "arrow-schema",
6550 "arrow-select",
6551 "async-recursion",
6552 "async-trait",
6553 "async_cell",
6554 "bitpacking",
6555 "byteorder",
6556 "bytes",
6557 "chrono",
6558 "crossbeam-queue",
6559 "crossbeam-skiplist",
6560 "dashmap",
6561 "datafusion",
6562 "datafusion-expr",
6563 "datafusion-functions",
6564 "datafusion-physical-expr",
6565 "datafusion-physical-plan",
6566 "deepsize",
6567 "either",
6568 "futures",
6569 "half",
6570 "humantime",
6571 "itertools 0.13.0",
6572 "lance-arrow",
6573 "lance-core",
6574 "lance-datafusion",
6575 "lance-encoding",
6576 "lance-file",
6577 "lance-index",
6578 "lance-io",
6579 "lance-linalg",
6580 "lance-namespace",
6581 "lance-table",
6582 "lance-tokenizer",
6583 "log 0.4.33",
6584 "moka",
6585 "object_store",
6586 "permutation",
6587 "pin-project",
6588 "prost",
6589 "prost-build",
6590 "prost-types",
6591 "rand 0.9.5",
6592 "rayon",
6593 "roaring",
6594 "semver",
6595 "serde",
6596 "serde_json",
6597 "snafu 0.9.2",
6598 "tokio",
6599 "tokio-stream",
6600 "tokio-util",
6601 "tracing",
6602 "url 2.5.8",
6603 "uuid",
4538 "block-padding",
4539 "hybrid-array",
66044540]
66054541
66064542[[package]]
6607name = "lance-arrow"
6608version = "7.0.0"
4543name = "internal-russh-num-bigint"
4544version = "0.5.0"
66094545source = "registry+https://github.com/rust-lang/crates.io-index"
6610checksum = "253f4a0a70580c985b91e65e9ca6cad644825a4078de28d8efbacf3ffbd7ecdc"
4546checksum = "ae8e22120c32fb4d19ec55fba35015f57095cd95a2e3b732e44457f5915b2ee8"
66114547dependencies = [
6612 "arrow-array",
6613 "arrow-buffer",
6614 "arrow-data",
6615 "arrow-ipc",
6616 "arrow-ord",
6617 "arrow-schema",
6618 "arrow-select",
6619 "bytes",
6620 "futures",
6621 "getrandom 0.2.17",
6622 "half",
6623 "jsonb",
4548 "num-integer",
66244549 "num-traits",
6625 "rand 0.9.5",
4550 "rand 0.10.2",
4551 "rand_core 0.10.1",
66264552]
66274553
66284554[[package]]
6629name = "lance-bitpacking"
6630version = "7.0.0"
4555name = "inventory"
4556version = "0.3.24"
66314557source = "registry+https://github.com/rust-lang/crates.io-index"
6632checksum = "80c4d12521b1945041dd515a56aa0854973138e7ac12111c92572e33e4ecb593"
4558checksum = "a4f0c30c76f2f4ccee3fe55a2435f691ca00c0e4bd87abe4f4a851b1d4dac39b"
66334559dependencies = [
6634 "arrayref",
6635 "paste",
6636 "seq-macro",
4560 "rustversion",
66374561]
66384562
66394563[[package]]
6640name = "lance-core"
6641version = "7.0.0"
4564name = "io-close"
4565version = "0.3.7"
66424566source = "registry+https://github.com/rust-lang/crates.io-index"
6643checksum = "13f84020da5a484e2f07dd1796e09785ed7cd889857ebc4cb77e32ef214ee594"
4567checksum = "9cadcf447f06744f8ce713d2d6239bb5bde2c357a452397a9ed90c625da390bc"
66444568dependencies = [
6645 "arrow-array",
6646 "arrow-buffer",
6647 "arrow-schema",
6648 "async-trait",
6649 "byteorder",
6650 "bytes",
6651 "datafusion-common",
6652 "datafusion-sql",
6653 "deepsize",
6654 "futures",
6655 "itertools 0.13.0",
6656 "lance-arrow",
66574569 "libc",
6658 "log 0.4.33",
6659 "moka",
6660 "num_cpus",
6661 "object_store",
6662 "pin-project",
6663 "prost",
6664 "rand 0.9.5",
6665 "roaring",
6666 "serde_json",
6667 "snafu 0.9.2",
6668 "tempfile",
6669 "tokio",
6670 "tokio-stream",
6671 "tokio-util",
6672 "tracing",
6673 "url 2.5.8",
4570 "winapi",
66744571]
66754572
66764573[[package]]
6677name = "lance-datafusion"
6678version = "7.0.0"
4574name = "io-uring"
4575version = "0.7.14"
66794576source = "registry+https://github.com/rust-lang/crates.io-index"
6680checksum = "7460597a66534a75987993d4dac5bc330586d99c5b79ae73367dbcbd4e29e576"
4577checksum = "d64d8ca234d152948ceaede1f419b6a83983a5ecccaac05fb337a809c96d3aa6"
66814578dependencies = [
6682 "arrow",
6683 "arrow-array",
6684 "arrow-buffer",
6685 "arrow-cast",
6686 "arrow-ord",
6687 "arrow-schema",
6688 "arrow-select",
6689 "async-trait",
6690 "chrono",
6691 "datafusion",
6692 "datafusion-common",
6693 "datafusion-functions",
6694 "datafusion-physical-expr",
6695 "futures",
6696 "jsonb",
6697 "lance-arrow",
6698 "lance-core",
6699 "lance-datagen",
6700 "log 0.4.33",
6701 "pin-project",
6702 "prost",
6703 "prost-build",
6704 "tokio",
6705 "tracing",
4579 "bitflags 2.13.1",
4580 "cfg-if",
4581 "libc",
67064582]
67074583
67084584[[package]]
6709name = "lance-datagen"
6710version = "7.0.0"
4585name = "ipnet"
4586version = "2.12.1"
67114587source = "registry+https://github.com/rust-lang/crates.io-index"
6712checksum = "046f5506ed2271cd941a050de7bf535dd3aedc291aadec836a63fa56c5926e3b"
6713dependencies = [
6714 "arrow",
6715 "arrow-array",
6716 "arrow-cast",
6717 "arrow-schema",
6718 "chrono",
6719 "futures",
6720 "half",
6721 "hex",
6722 "rand 0.9.5",
6723 "rand_distr",
6724 "rand_xoshiro",
6725 "random_word",
6726]
4588checksum = "6a756c3fac73139e83f14c2d742155dd2b78d3ee56597b419a0579b7bdd6dd78"
67274589
67284590[[package]]
6729name = "lance-encoding"
6730version = "7.0.0"
6731source = "registry+https://github.com/rust-lang/crates.io-index"
6732checksum = "7af54edf43dcf9d6a56cc636eb35d457e68373c6448dca3f0891b3325b4a24e6"
4591name = "issues"
4592version = "1.0.0"
67334593dependencies = [
6734 "arrow-arith",
6735 "arrow-array",
6736 "arrow-buffer",
6737 "arrow-cast",
6738 "arrow-data",
6739 "arrow-schema",
6740 "arrow-select",
6741 "bytemuck",
6742 "byteorder",
6743 "bytes",
6744 "fsst",
6745 "futures",
6746 "hex",
6747 "hyperloglogplus",
6748 "itertools 0.13.0",
6749 "lance-arrow",
6750 "lance-bitpacking",
6751 "lance-core",
6752 "log 0.4.33",
6753 "lz4",
6754 "num-traits",
6755 "prost",
6756 "prost-build",
6757 "rand 0.9.5",
6758 "strum 0.26.3",
6759 "tokio",
4594 "async-trait",
4595 "axum",
4596 "config",
4597 "email",
4598 "export",
4599 "models",
4600 "sea-orm",
4601 "serde",
4602 "serde_json",
4603 "session",
4604 "space",
4605 "time 0.3.55",
67604606 "tracing",
6761 "xxhash-rust",
6762 "zstd",
4607 "utoipa",
4608 "uuid",
67634609]
67644610
67654611[[package]]
6766name = "lance-file"
6767version = "7.0.0"
4612name = "itertools"
4613version = "0.14.0"
67684614source = "registry+https://github.com/rust-lang/crates.io-index"
6769checksum = "0772ae2d6207995dc1eb28aff9507f78e90b3362b58f311da001e9dc25f3d736"
4615checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
67704616dependencies = [
6771 "arrow-arith",
6772 "arrow-array",
6773 "arrow-buffer",
6774 "arrow-data",
6775 "arrow-schema",
6776 "arrow-select",
6777 "async-recursion",
6778 "async-trait",
6779 "byteorder",
6780 "bytes",
6781 "datafusion-common",
6782 "deepsize",
6783 "futures",
6784 "lance-arrow",
6785 "lance-core",
6786 "lance-encoding",
6787 "lance-io",
6788 "log 0.4.33",
6789 "num-traits",
6790 "object_store",
6791 "prost",
6792 "prost-build",
6793 "prost-types",
6794 "tokio",
6795 "tracing",
4617 "either",
67964618]
67974619
67984620[[package]]
6799name = "lance-index"
6800version = "7.0.0"
4621name = "itertools"
4622version = "0.15.0"
68014623source = "registry+https://github.com/rust-lang/crates.io-index"
6802checksum = "e71fbfb51096a903cb524fe0da716f5f15fbc4a6b6f84cd6dec21abf319c5e84"
4624checksum = "8b4baf93f58d4425749ca49a51c50ebab072c5df6994d08fed93541c331481dc"
68034625dependencies = [
6804 "arc-swap",
6805 "arrow",
6806 "arrow-arith",
6807 "arrow-array",
6808 "arrow-ord",
6809 "arrow-schema",
6810 "arrow-select",
6811 "async-channel",
6812 "async-recursion",
6813 "async-trait",
6814 "bitpacking",
6815 "bitvec",
6816 "bytes",
6817 "chrono",
6818 "crossbeam-queue",
6819 "datafusion",
6820 "datafusion-common",
6821 "datafusion-expr",
6822 "datafusion-physical-expr",
6823 "deepsize",
6824 "dirs 6.0.0",
6825 "fst",
6826 "futures",
6827 "half",
6828 "itertools 0.13.0",
6829 "jieba-rs",
6830 "jsonb",
6831 "lance-arrow",
6832 "lance-core",
6833 "lance-datafusion",
6834 "lance-datagen",
6835 "lance-encoding",
6836 "lance-file",
6837 "lance-io",
6838 "lance-linalg",
6839 "lance-table",
6840 "lance-tokenizer",
6841 "libm",
6842 "log 0.4.33",
6843 "ndarray",
6844 "num-traits",
6845 "object_store",
6846 "prost",
6847 "prost-build",
6848 "prost-types",
6849 "rand 0.9.5",
6850 "rand_distr",
6851 "rangemap",
6852 "rayon",
6853 "roaring",
6854 "serde",
6855 "serde_json",
6856 "smallvec",
6857 "tempfile",
6858 "tokio",
6859 "tracing",
6860 "twox-hash",
6861 "uuid",
4626 "either",
68624627]
68634628
68644629[[package]]
6865name = "lance-io"
6866version = "7.0.0"
4630name = "itoa"
4631version = "1.0.18"
4632source = "registry+https://github.com/rust-lang/crates.io-index"
4633checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
4634
4635[[package]]
4636name = "ixdtf"
4637version = "0.6.6"
4638source = "registry+https://github.com/rust-lang/crates.io-index"
4639checksum = "4d3667095d64c3ecffc96463a21157b04bf3e252f6e8d5750b20c02e33c194e3"
4640
4641[[package]]
4642name = "jiff"
4643version = "0.2.35"
68674644source = "registry+https://github.com/rust-lang/crates.io-index"
6868checksum = "bab8c98ef1b870b20541d27f3ca4efdf7c9f5c25214233be07d231ba88900219"
4645checksum = "668b7183bd07af9a4885f5c35b0cc5c83c4607a913c16b7e17291832910d2dcc"
68694646dependencies = [
6870 "arrow",
6871 "arrow-arith",
6872 "arrow-array",
6873 "arrow-buffer",
6874 "arrow-cast",
6875 "arrow-data",
6876 "arrow-schema",
6877 "arrow-select",
6878 "async-recursion",
6879 "async-trait",
6880 "byteorder",
6881 "bytes",
6882 "chrono",
6883 "deepsize",
6884 "futures",
6885 "http 1.5.0",
6886 "io-uring",
6887 "lance-arrow",
6888 "lance-core",
6889 "lance-namespace",
4647 "defmt",
4648 "jiff-core",
4649 "jiff-static",
4650 "jiff-tzdb-platform",
68904651 "log 0.4.33",
6891 "moka",
6892 "object_store",
6893 "path_abs",
6894 "pin-project",
6895 "prost",
6896 "rand 0.9.5",
6897 "serde",
6898 "tempfile",
6899 "tokio",
6900 "tracing",
6901 "url 2.5.8",
4652 "portable-atomic",
4653 "portable-atomic-util",
4654 "serde_core",
4655 "windows-link",
69024656]
69034657
69044658[[package]]
6905name = "lance-linalg"
6906version = "7.0.0"
4659name = "jiff-core"
4660version = "0.1.0"
69074661source = "registry+https://github.com/rust-lang/crates.io-index"
6908checksum = "6b4c51cad0ac780b02dc4da48528479e7693c03e8d05390510bbc69ca2a9a1f1"
4662checksum = "7feca88439efe53da3754500c1851dedf3cb36c524dd5cf8225cc0794de95d09"
69094663dependencies = [
6910 "arrow-array",
6911 "arrow-buffer",
6912 "arrow-schema",
6913 "cc",
6914 "deepsize",
6915 "half",
6916 "lance-arrow",
6917 "lance-core",
6918 "num-traits",
6919 "rand 0.9.5",
4664 "defmt",
69204665]
69214666
69224667[[package]]
6923name = "lance-namespace"
6924version = "7.0.0"
4668name = "jiff-static"
4669version = "0.2.35"
69254670source = "registry+https://github.com/rust-lang/crates.io-index"
6926checksum = "014e8332ca0615506342e0d3af608639864b68396973be14239f09c9f21f1fc2"
4671checksum = "3a69dcb3a21cfb32ce1cd056169337ca284af0766dd766e7878819b251a49204"
69274672dependencies = [
6928 "arrow",
6929 "async-trait",
6930 "bytes",
6931 "lance-core",
6932 "lance-namespace-reqwest-client",
6933 "snafu 0.9.2",
4673 "jiff-core",
4674 "proc-macro2",
4675 "quote",
4676 "syn 2.0.119",
69344677]
69354678
69364679[[package]]
6937name = "lance-namespace-impls"
6938version = "7.0.0"
4680name = "jiff-tzdb"
4681version = "0.1.8"
69394682source = "registry+https://github.com/rust-lang/crates.io-index"
6940checksum = "e8d1231906a3cf92dd3dcda7d14a09c4835af6cd2bcd76dfd2481e87f20a282d"
6941dependencies = [
6942 "arrow",
6943 "arrow-ipc",
6944 "arrow-schema",
6945 "async-trait",
6946 "bytes",
6947 "futures",
6948 "lance",
6949 "lance-core",
6950 "lance-index",
6951 "lance-io",
6952 "lance-linalg",
6953 "lance-namespace",
6954 "lance-table",
6955 "log 0.4.33",
6956 "object_store",
6957 "rand 0.9.5",
6958 "serde_json",
6959 "tokio",
6960 "url 2.5.8",
6961]
4683checksum = "142bd39932ad231f10513df9ab62661fead8719872150b7ad02a2df79f4e141e"
69624684
69634685[[package]]
6964name = "lance-namespace-reqwest-client"
6965version = "0.7.7"
4686name = "jiff-tzdb-platform"
4687version = "0.1.3"
69664688source = "registry+https://github.com/rust-lang/crates.io-index"
6967checksum = "6369eee4682fb11edf538388b43c61ce288b8302fe89bb40944d7daa7faaae99"
4689checksum = "875a5a69ac2bab1a891711cf5eccbec1ce0341ea805560dcd90b7a2e925132e8"
69684690dependencies = [
6969 "reqwest 0.12.28",
6970 "serde",
6971 "serde_json",
6972 "serde_repr",
6973 "serde_with",
6974 "url 2.5.8",
4691 "jiff-tzdb",
69754692]
69764693
69774694[[package]]
6978name = "lance-table"
6979version = "7.0.0"
4695name = "jobserver"
4696version = "0.1.35"
69804697source = "registry+https://github.com/rust-lang/crates.io-index"
6981checksum = "b16f1355904aea4ebb04ffc70c58c97901e10bde44452b4b021de4a1f329250d"
4698checksum = "1c00acbd29eabad4a2392fa0e921c874934dbbf4194312ad20f04a0ed67a3cb3"
69824699dependencies = [
6983 "arrow",
6984 "arrow-array",
6985 "arrow-buffer",
6986 "arrow-ipc",
6987 "arrow-schema",
6988 "async-trait",
6989 "byteorder",
6990 "bytes",
6991 "chrono",
6992 "deepsize",
6993 "futures",
6994 "lance-arrow",
6995 "lance-core",
6996 "lance-file",
6997 "lance-io",
6998 "log 0.4.33",
6999 "object_store",
7000 "prost",
7001 "prost-build",
7002 "prost-types",
7003 "rand 0.9.5",
7004 "rangemap",
7005 "roaring",
7006 "semver",
7007 "serde",
7008 "serde_json",
7009 "snafu 0.9.2",
7010 "tokio",
7011 "tracing",
7012 "url 2.5.8",
7013 "uuid",
4700 "getrandom 0.4.3",
4701 "libc",
70144702]
70154703
70164704[[package]]
7017name = "lance-testing"
7018version = "7.0.0"
4705name = "js-sys"
4706version = "0.3.104"
70194707source = "registry+https://github.com/rust-lang/crates.io-index"
7020checksum = "3094c2aacbd1fa093d809fc54fa911e3498671ba451041341d7caaa18460e6b2"
4708checksum = "0e0c1080212aad755ea003d18543e8768dd432c48819efd73a7bf1e39b7a5a3a"
70214709dependencies = [
7022 "arrow-array",
7023 "arrow-schema",
7024 "lance-arrow",
7025 "num-traits",
7026 "rand 0.9.5",
4710 "cfg-if",
4711 "futures-util",
4712 "wasm-bindgen",
70274713]
70284714
70294715[[package]]
7030name = "lance-tokenizer"
7031version = "7.0.0"
4716name = "keccak"
4717version = "0.2.1"
70324718source = "registry+https://github.com/rust-lang/crates.io-index"
7033checksum = "b39b7f5ed9d0c0b716bf599b559d888267ed1dfe4c4e29d3648b51d2a28940cf"
4719checksum = "ffd9697dc4a9a62e2da93389f34400b77a28f0287711263cabb203b3ccb9c0e4"
70344720dependencies = [
7035 "jieba-rs",
7036 "lindera",
7037 "rust-stemmers",
7038 "serde",
7039 "unicode-normalization",
4721 "cfg-if",
4722 "cpufeatures 0.3.0",
70404723]
70414724
70424725[[package]]
7043name = "lancedb"
7044version = "0.30.0"
4726name = "kem"
4727version = "0.3.0"
70454728source = "registry+https://github.com/rust-lang/crates.io-index"
7046checksum = "9db595d8da6c1fbf41ef6a547f27a73cc1105d83a837e8c76ce08743a3c09260"
4729checksum = "01737161ba802849cfd486b5bd209d38ba4943494c249a8126005170c7621edd"
70474730dependencies = [
7048 "ahash 0.8.12",
7049 "arrow",
7050 "arrow-array",
7051 "arrow-cast",
7052 "arrow-data",
7053 "arrow-ipc",
7054 "arrow-ord",
7055 "arrow-schema",
7056 "arrow-select",
7057 "async-trait",
7058 "bytes",
7059 "chrono",
7060 "datafusion",
7061 "datafusion-catalog",
7062 "datafusion-common",
7063 "datafusion-execution",
7064 "datafusion-expr",
7065 "datafusion-functions",
7066 "datafusion-physical-expr",
7067 "datafusion-physical-plan",
7068 "datafusion-sql",
7069 "futures",
7070 "half",
7071 "lance",
7072 "lance-arrow",
7073 "lance-core",
7074 "lance-datafusion",
7075 "lance-datagen",
7076 "lance-encoding",
7077 "lance-file",
7078 "lance-index",
7079 "lance-io",
7080 "lance-linalg",
7081 "lance-namespace",
7082 "lance-namespace-impls",
7083 "lance-table",
7084 "lance-testing",
7085 "lazy_static",
7086 "log 0.4.33",
7087 "moka",
7088 "num-traits",
7089 "object_store",
7090 "pin-project",
7091 "rand 0.9.5",
7092 "regex",
7093 "semver",
7094 "serde",
7095 "serde_json",
7096 "serde_with",
7097 "snafu 0.8.9",
7098 "tempfile",
7099 "tokio",
7100 "url 2.5.8",
7101 "uuid",
4731 "crypto-common 0.2.2",
4732 "rand_core 0.10.1",
71024733]
71034734
71044735[[package]]
@@ -7117,12 +4748,6 @@
71174748]
71184749
71194750[[package]]
7120name = "lebe"
7121version = "0.5.3"
7122source = "registry+https://github.com/rust-lang/crates.io-index"
7123checksum = "7a79a3332a6609480d7d0c9eab957bca6b455b91bb84e66d19f5ff66294b85b8"
7124
7125[[package]]
71264751name = "lettre"
71274752version = "0.11.23"
71284753source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -7138,7 +4763,7 @@
71384763 "httpdate",
71394764 "idna 1.1.0",
71404765 "mime 0.3.17",
7141 "nom 8.0.0",
4766 "nom",
71424767 "percent-encoding 2.3.2",
71434768 "quoted_printable",
71444769 "rustls",
@@ -7213,16 +4838,6 @@
72134838checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
72144839
72154840[[package]]
7216name = "libfuzzer-sys"
7217version = "0.4.13"
7218source = "registry+https://github.com/rust-lang/crates.io-index"
7219checksum = "a9fd2f41a1cba099f79a0b6b6c35656cf7c03351a7bae8ff0f28f25270f929d2"
7220dependencies = [
7221 "arbitrary",
7222 "cc",
7223]
7224
7225[[package]]
72264841name = "libm"
72274842version = "0.2.16"
72284843source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -7238,67 +4853,13 @@
72384853]
72394854
72404855[[package]]
7241name = "libsqlite3-sys"
7242version = "0.37.0"
7243source = "registry+https://github.com/rust-lang/crates.io-index"
7244checksum = "b1f111c8c41e7c61a49cd34e44c7619462967221a6443b0ec299e0ac30cfb9b1"
7245dependencies = [
7246 "pkg-config",
7247 "vcpkg",
7248]
7249
7250[[package]]
7251name = "lindera"
7252version = "3.0.7"
7253source = "registry+https://github.com/rust-lang/crates.io-index"
7254checksum = "74cda79d7161e99b414e4d292ff673cc3f8d22f070d8be3b6185c033363a9216"
7255dependencies = [
7256 "anyhow",
7257 "byteorder",
7258 "csv",
7259 "daachorse",
7260 "kanaria",
7261 "lindera-dictionary",
7262 "log 0.4.33",
7263 "once_cell",
7264 "percent-encoding 2.3.2",
7265 "regex",
7266 "serde",
7267 "serde_json",
7268 "serde_yaml_ng",
7269 "strum 0.28.0",
7270 "strum_macros 0.28.0",
7271 "unicode-blocks",
7272 "unicode-normalization",
7273 "unicode-segmentation",
7274 "url 2.5.8",
7275]
7276
7277[[package]]
7278name = "lindera-dictionary"
7279version = "3.0.7"
4856name = "libsqlite3-sys"
4857version = "0.37.0"
72804858source = "registry+https://github.com/rust-lang/crates.io-index"
7281checksum = "e2385456ca9fe87c29072c5f156b52fdd5e28d5b5738ddfb3979501dbd736530"
4859checksum = "b1f111c8c41e7c61a49cd34e44c7619462967221a6443b0ec299e0ac30cfb9b1"
72824860dependencies = [
7283 "anyhow",
7284 "byteorder",
7285 "csv",
7286 "daachorse",
7287 "derive_builder",
7288 "encoding_rs",
7289 "encoding_rs_io",
7290 "glob",
7291 "log 0.4.33",
7292 "memmap2",
7293 "num_cpus",
7294 "once_cell",
7295 "regex",
7296 "rkyv 0.8.18",
7297 "serde",
7298 "serde_json",
7299 "strum 0.28.0",
7300 "strum_macros 0.28.0",
7301 "thiserror 2.0.20",
4861 "pkg-config",
4862 "vcpkg",
73024863]
73034864
73044865[[package]]
@@ -7338,28 +4899,6 @@
73384899checksum = "0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad"
73394900
73404901[[package]]
7341name = "loom"
7342version = "0.7.2"
7343source = "registry+https://github.com/rust-lang/crates.io-index"
7344checksum = "419e0dc8046cb947daa77eb95ae174acfbddb7673b4151f56d1eed8e93fbfaca"
7345dependencies = [
7346 "cfg-if",
7347 "generator",
7348 "scoped-tls",
7349 "tracing",
7350 "tracing-subscriber",
7351]
7352
7353[[package]]
7354name = "loop9"
7355version = "0.1.5"
7356source = "registry+https://github.com/rust-lang/crates.io-index"
7357checksum = "0fae87c125b03c1d2c0150c90365d7d6bcc53fb73a9acaef207d2d065860f062"
7358dependencies = [
7359 "imgref",
7360]
7361
7362[[package]]
73634902name = "lru-slab"
73644903version = "0.1.2"
73654904source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -7385,15 +4924,6 @@
73854924]
73864925
73874926[[package]]
7388name = "lz4_flex"
7389version = "0.13.1"
7390source = "registry+https://github.com/rust-lang/crates.io-index"
7391checksum = "7ef0d4ed8669f8f8826eb00dc878084aa8f253506c4fd5e8f58f5bce72ddb97e"
7392dependencies = [
7393 "twox-hash",
7394]
7395
7396[[package]]
73974927name = "mac_address"
73984928version = "1.1.8"
73994929source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -7405,22 +4935,6 @@
74054935]
74064936
74074937[[package]]
7408name = "macro_rules_attribute"
7409version = "0.2.3"
7410source = "registry+https://github.com/rust-lang/crates.io-index"
7411checksum = "b3ae8f6d608c795738406608304d30a2dfbdc8e58e44f7ba43236da5208ded3c"
7412dependencies = [
7413 "macro_rules_attribute-proc_macro",
7414 "pastey 0.2.3",
7415]
7416
7417[[package]]
7418name = "macro_rules_attribute-proc_macro"
7419version = "0.2.3"
7420source = "registry+https://github.com/rust-lang/crates.io-index"
7421checksum = "fc04a4c58212d57930a24bf47d3fa87485264a3a054e9c10e042eb373573ad3c"
7422
7423[[package]]
74244938name = "mails"
74254939version = "1.0.0"
74264940dependencies = [
@@ -7454,19 +4968,6 @@
74544968checksum = "47e1ffaa40ddd1f3ed91f717a33c8c0ee23fff369e3aa8772b9605cc1d22f4c3"
74554969
74564970[[package]]
7457name = "matrixmultiply"
7458version = "0.3.11"
7459source = "registry+https://github.com/rust-lang/crates.io-index"
7460checksum = "3f607c237553f086e7043417a51df26b2eb899d3caff94e6a67592ff992fedc7"
7461dependencies = [
7462 "autocfg",
7463 "num_cpus",
7464 "once_cell",
7465 "rawpointer",
7466 "thread-tree",
7467]
7468
7469[[package]]
74704971name = "maud"
74714972version = "0.27.0"
74724973source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -7491,26 +4992,6 @@
74914992]
74924993
74934994[[package]]
7494name = "maybe-rayon"
7495version = "0.1.1"
7496source = "registry+https://github.com/rust-lang/crates.io-index"
7497checksum = "8ea1f30cedd69f0a2954655f7188c6a834246d2bcf1e315e2ac40c4b24dc9519"
7498dependencies = [
7499 "cfg-if",
7500 "rayon",
7501]
7502
7503[[package]]
7504name = "md-5"
7505version = "0.10.6"
7506source = "registry+https://github.com/rust-lang/crates.io-index"
7507checksum = "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf"
7508dependencies = [
7509 "cfg-if",
7510 "digest 0.10.7",
7511]
7512
7513[[package]]
75144995name = "md-5"
75154996version = "0.11.0"
75164997source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -7614,12 +5095,6 @@
76145095]
76155096
76165097[[package]]
7617name = "minimal-lexical"
7618version = "0.2.1"
7619source = "registry+https://github.com/rust-lang/crates.io-index"
7620checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
7621
7622[[package]]
76235098name = "miniz_oxide"
76245099version = "0.8.9"
76255100source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -7709,38 +5184,6 @@
77095184]
77105185
77115186[[package]]
7712name = "monostate"
7713version = "0.1.18"
7714source = "registry+https://github.com/rust-lang/crates.io-index"
7715checksum = "3341a273f6c9d5bef1908f17b7267bbab0e95c9bf69a0d4dcf8e9e1b2c76ef67"
7716dependencies = [
7717 "monostate-impl",
7718 "serde",
7719 "serde_core",
7720]
7721
7722[[package]]
7723name = "monostate-impl"
7724version = "0.1.18"
7725source = "registry+https://github.com/rust-lang/crates.io-index"
7726checksum = "e4db6d5580af57bf992f59068d4ea26fd518574ff48d7639b255a36f9de6e7e9"
7727dependencies = [
7728 "proc-macro2",
7729 "quote",
7730 "syn 2.0.119",
7731]
7732
7733[[package]]
7734name = "moxcms"
7735version = "0.8.1"
7736source = "registry+https://github.com/rust-lang/crates.io-index"
7737checksum = "bb85c154ba489f01b25c0d36ae69a87e4a1c73a72631fc6c0eb6dde34a73e44b"
7738dependencies = [
7739 "num-traits",
7740 "pxfm",
7741]
7742
7743[[package]]
77445187name = "multer"
77455188version = "3.1.0"
77465189source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -7758,32 +5201,6 @@
77585201]
77595202
77605203[[package]]
7761name = "multimap"
7762version = "0.10.1"
7763source = "registry+https://github.com/rust-lang/crates.io-index"
7764checksum = "1d87ecb2933e8aeadb3e3a02b828fed80a7528047e68b4f424523a0981a3a084"
7765
7766[[package]]
7767name = "munge"
7768version = "0.4.7"
7769source = "registry+https://github.com/rust-lang/crates.io-index"
7770checksum = "5e17401f259eba956ca16491461b6e8f72913a0a114e39736ce404410f915a0c"
7771dependencies = [
7772 "munge_macro",
7773]
7774
7775[[package]]
7776name = "munge_macro"
7777version = "0.4.7"
7778source = "registry+https://github.com/rust-lang/crates.io-index"
7779checksum = "4568f25ccbd45ab5d5603dc34318c1ec56b117531781260002151b8530a9f931"
7780dependencies = [
7781 "proc-macro2",
7782 "quote",
7783 "syn 2.0.119",
7784]
7785
7786[[package]]
77875204name = "native-tls"
77885205version = "0.2.18"
77895206source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -7801,27 +5218,6 @@
78015218]
78025219
78035220[[package]]
7804name = "ndarray"
7805version = "0.16.1"
7806source = "registry+https://github.com/rust-lang/crates.io-index"
7807checksum = "882ed72dce9365842bf196bdeedf5055305f11fc8c03dee7bb0194a6cad34841"
7808dependencies = [
7809 "matrixmultiply",
7810 "num-complex",
7811 "num-integer",
7812 "num-traits",
7813 "portable-atomic",
7814 "portable-atomic-util",
7815 "rawpointer",
7816]
7817
7818[[package]]
7819name = "new_debug_unreachable"
7820version = "1.0.6"
7821source = "registry+https://github.com/rust-lang/crates.io-index"
7822checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"
7823
7824[[package]]
78255221name = "nix"
78265222version = "0.29.0"
78275223source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -7847,40 +5243,6 @@
78475243]
78485244
78495245[[package]]
7850name = "nkeys"
7851version = "0.4.5"
7852source = "registry+https://github.com/rust-lang/crates.io-index"
7853checksum = "879011babc47a1c7fdf5a935ae3cfe94f34645ca0cac1c7f6424b36fc743d1bf"
7854dependencies = [
7855 "data-encoding",
7856 "ed25519 2.2.3",
7857 "ed25519-dalek 2.2.0",
7858 "getrandom 0.2.17",
7859 "log 0.4.33",
7860 "rand 0.8.7",
7861 "signatory",
7862]
7863
7864[[package]]
7865name = "no_std_io2"
7866version = "0.9.4"
7867source = "registry+https://github.com/rust-lang/crates.io-index"
7868checksum = "418abd1b6d34fbf6cae440dc874771b0525a604428704c76e48b29a5e67b8003"
7869dependencies = [
7870 "memchr",
7871]
7872
7873[[package]]
7874name = "nom"
7875version = "7.1.3"
7876source = "registry+https://github.com/rust-lang/crates.io-index"
7877checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
7878dependencies = [
7879 "memchr",
7880 "minimal-lexical",
7881]
7882
7883[[package]]
78845246name = "nom"
78855247version = "8.0.0"
78865248source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -7905,12 +5267,6 @@
79055267]
79065268
79075269[[package]]
7908name = "noop_proc_macro"
7909version = "0.3.0"
7910source = "registry+https://github.com/rust-lang/crates.io-index"
7911checksum = "0676bb32a98c1a483ce53e500a81ad9c3d5b3f7c920c28c24e9cb0980d0b5bc8"
7912
7913[[package]]
79145270name = "nu-ansi-term"
79155271version = "0.50.3"
79165272source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -7920,15 +5276,6 @@
79205276]
79215277
79225278[[package]]
7923name = "nuid"
7924version = "0.5.0"
7925source = "registry+https://github.com/rust-lang/crates.io-index"
7926checksum = "fc895af95856f929163a0aa20c26a78d26bfdc839f51b9d5aa7a5b79e52b7e83"
7927dependencies = [
7928 "rand 0.8.7",
7929]
7930
7931[[package]]
79325279name = "num-bigint"
79335280version = "0.4.8"
79345281source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -7970,7 +5317,6 @@
79705317source = "registry+https://github.com/rust-lang/crates.io-index"
79715318checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"
79725319dependencies = [
7973 "bytemuck",
79745320 "num-traits",
79755321]
79765322
@@ -7981,17 +5327,6 @@
79815327checksum = "521739c6d2bac4aa25192232afe6841231376b2b26d4d9fae5ecf8ca5772e441"
79825328
79835329[[package]]
7984name = "num-derive"
7985version = "0.4.2"
7986source = "registry+https://github.com/rust-lang/crates.io-index"
7987checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202"
7988dependencies = [
7989 "proc-macro2",
7990 "quote",
7991 "syn 2.0.119",
7992]
7993
7994[[package]]
79955330name = "num-integer"
79965331version = "0.1.47"
79975332source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -8057,12 +5392,6 @@
80575392]
80585393
80595394[[package]]
8060name = "number_prefix"
8061version = "0.4.0"
8062source = "registry+https://github.com/rust-lang/crates.io-index"
8063checksum = "830b246a0e5f20af87141b25c173cd1b609bd7779a4617d6ec582abaf90870f3"
8064
8065[[package]]
80665395name = "object"
80675396version = "0.39.1"
80685397source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -8072,60 +5401,12 @@
80725401]
80735402
80745403[[package]]
8075name = "object_store"
8076version = "0.13.2"
8077source = "registry+https://github.com/rust-lang/crates.io-index"
8078checksum = "622acbc9100d3c10e2ee15804b0caa40e55c933d5aa53814cd520805b7958a49"
8079dependencies = [
8080 "async-trait",
8081 "bytes",
8082 "chrono",
8083 "futures-channel",
8084 "futures-core",
8085 "futures-util",
8086 "http 1.5.0",
8087 "humantime",
8088 "itertools 0.14.0",
8089 "parking_lot",
8090 "percent-encoding 2.3.2",
8091 "thiserror 2.0.20",
8092 "tokio",
8093 "tracing",
8094 "url 2.5.8",
8095 "walkdir",
8096 "wasm-bindgen-futures",
8097 "web-time",
8098]
8099
8100[[package]]
81015404name = "once_cell"
81025405version = "1.21.4"
81035406source = "registry+https://github.com/rust-lang/crates.io-index"
81045407checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
81055408
81065409[[package]]
8107name = "onig"
8108version = "6.5.3"
8109source = "registry+https://github.com/rust-lang/crates.io-index"
8110checksum = "0cc3cbf698f9438986c11a880c90a6d04b9de27575afd28bbf45b154b6c709e2"
8111dependencies = [
8112 "bitflags 2.13.1",
8113 "libc",
8114 "once_cell",
8115 "onig_sys",
8116]
8117
8118[[package]]
8119name = "onig_sys"
8120version = "69.9.3"
8121source = "registry+https://github.com/rust-lang/crates.io-index"
8122checksum = "1e68317604e77e53b85896388e1a803c1d21b74c899ec9e5e1112db90735edd7"
8123dependencies = [
8124 "cc",
8125 "pkg-config",
8126]
8127
8128[[package]]
81295410name = "opaque-debug"
81305411version = "0.3.1"
81315412source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -8276,15 +5557,6 @@
82765557]
82775558
82785559[[package]]
8279name = "ordered-float"
8280version = "5.5.0"
8281source = "registry+https://github.com/rust-lang/crates.io-index"
8282checksum = "8c7c9e0d9b23589f26070720bac724174bfec1083e82f7854cdd0267518343c0"
8283dependencies = [
8284 "num-traits",
8285]
8286
8287[[package]]
82885560name = "ordered-multimap"
82895561version = "0.4.3"
82905562source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -8295,26 +5567,6 @@
82955567]
82965568
82975569[[package]]
8298name = "ort"
8299version = "2.0.0-rc.9"
8300source = "registry+https://github.com/rust-lang/crates.io-index"
8301checksum = "52afb44b6b0cffa9bf45e4d37e5a4935b0334a51570658e279e9e3e6cf324aa5"
8302dependencies = [
8303 "ndarray",
8304 "ort-sys",
8305 "tracing",
8306]
8307
8308[[package]]
8309name = "ort-sys"
8310version = "2.0.0-rc.9"
8311source = "registry+https://github.com/rust-lang/crates.io-index"
8312checksum = "c41d7757331aef2d04b9cb09b45583a59217628beaf91895b7e76187b6e8c088"
8313dependencies = [
8314 "pkg-config",
8315]
8316
8317[[package]]
83185570name = "ouroboros"
83195571version = "0.18.5"
83205572source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -8405,7 +5657,7 @@
84055657dependencies = [
84065658 "ecdsa 0.17.0",
84075659 "elliptic-curve 0.14.1",
8408 "fiat-crypto 0.3.0",
5660 "fiat-crypto",
84095661 "primefield",
84105662 "primeorder 0.14.0",
84115663 "sha2 0.11.0",
@@ -8499,34 +5751,10 @@
84995751]
85005752
85015753[[package]]
8502name = "paste"
8503version = "1.0.15"
8504source = "registry+https://github.com/rust-lang/crates.io-index"
8505checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
8506
8507[[package]]
8508name = "pastey"
8509version = "0.1.1"
8510source = "registry+https://github.com/rust-lang/crates.io-index"
8511checksum = "35fb2e5f958ec131621fdd531e9fc186ed768cbe395337403ae56c17a74c68ec"
8512
8513[[package]]
8514name = "pastey"
8515version = "0.2.3"
8516source = "registry+https://github.com/rust-lang/crates.io-index"
8517checksum = "2ee67f1008b1ba2321834326597b8e186293b049a023cdef258527550b9935b4"
8518
8519[[package]]
8520name = "path_abs"
8521version = "0.5.1"
5754name = "paste"
5755version = "1.0.15"
85225756source = "registry+https://github.com/rust-lang/crates.io-index"
8523checksum = "05ef02f6342ac01d8a93b65f96db53fe68a92a15f41144f97fb00a9e669633c3"
8524dependencies = [
8525 "serde",
8526 "serde_derive",
8527 "std_prelude",
8528 "stfu8",
8529]
5757checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
85305758
85315759[[package]]
85325760name = "pbkdf2"
@@ -8592,12 +5820,6 @@
85925820checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
85935821
85945822[[package]]
8595name = "permutation"
8596version = "0.4.1"
8597source = "registry+https://github.com/rust-lang/crates.io-index"
8598checksum = "df202b0b0f5b8e389955afd5f27b007b00fb948162953f1db9c70d2c7e3157d7"
8599
8600[[package]]
86015823name = "pest"
86025824version = "2.9.0"
86035825source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -8640,18 +5862,6 @@
86405862]
86415863
86425864[[package]]
8643name = "petgraph"
8644version = "0.8.3"
8645source = "registry+https://github.com/rust-lang/crates.io-index"
8646checksum = "8701b58ea97060d5e5b155d383a69952a60943f0e6dfe30b04c287beb0b27455"
8647dependencies = [
8648 "fixedbitset",
8649 "hashbrown 0.15.5",
8650 "indexmap 2.14.0",
8651 "serde",
8652]
8653
8654[[package]]
86555865name = "pgvector"
86565866version = "0.4.2"
86575867source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -8672,63 +5882,6 @@
86725882]
86735883
86745884[[package]]
8675name = "phf"
8676version = "0.12.1"
8677source = "registry+https://github.com/rust-lang/crates.io-index"
8678checksum = "913273894cec178f401a31ec4b656318d95473527be05c0752cc41cdc32be8b7"
8679dependencies = [
8680 "phf_shared 0.12.1",
8681]
8682
8683[[package]]
8684name = "phf"
8685version = "0.13.1"
8686source = "registry+https://github.com/rust-lang/crates.io-index"
8687checksum = "c1562dc717473dbaa4c1f85a36410e03c047b2e7df7f45ee938fbef64ae7fadf"
8688dependencies = [
8689 "phf_shared 0.13.1",
8690 "serde",
8691]
8692
8693[[package]]
8694name = "phf_codegen"
8695version = "0.13.1"
8696source = "registry+https://github.com/rust-lang/crates.io-index"
8697checksum = "49aa7f9d80421bca176ca8dbfebe668cc7a2684708594ec9f3c0db0805d5d6e1"
8698dependencies = [
8699 "phf_generator",
8700 "phf_shared 0.13.1",
8701]
8702
8703[[package]]
8704name = "phf_generator"
8705version = "0.13.1"
8706source = "registry+https://github.com/rust-lang/crates.io-index"
8707checksum = "135ace3a761e564ec88c03a77317a7c6b80bb7f7135ef2544dbe054243b89737"
8708dependencies = [
8709 "fastrand",
8710 "phf_shared 0.13.1",
8711]
8712
8713[[package]]
8714name = "phf_shared"
8715version = "0.12.1"
8716source = "registry+https://github.com/rust-lang/crates.io-index"
8717checksum = "06005508882fb681fd97892ecff4b7fd0fee13ef1aa569f8695dae7ab9099981"
8718dependencies = [
8719 "siphasher",
8720]
8721
8722[[package]]
8723name = "phf_shared"
8724version = "0.13.1"
8725source = "registry+https://github.com/rust-lang/crates.io-index"
8726checksum = "e57fef6bc5981e38c2ce2d63bfa546861309f875b8a75f092d1d54ae2d64f266"
8727dependencies = [
8728 "siphasher",
8729]
8730
8731[[package]]
87325885name = "pin-project"
87335886version = "1.1.13"
87345887source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -8831,19 +5984,6 @@
88315984]
88325985
88335986[[package]]
8834name = "png"
8835version = "0.18.1"
8836source = "registry+https://github.com/rust-lang/crates.io-index"
8837checksum = "60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61"
8838dependencies = [
8839 "bitflags 2.13.1",
8840 "crc32fast",
8841 "fdeflate",
8842 "flate2",
8843 "miniz_oxide",
8844]
8845
8846[[package]]
88475987name = "polling"
88485988version = "3.11.0"
88495989source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -8942,16 +6082,6 @@
89426082]
89436083
89446084[[package]]
8945name = "prettyplease"
8946version = "0.2.37"
8947source = "registry+https://github.com/rust-lang/crates.io-index"
8948checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
8949dependencies = [
8950 "proc-macro2",
8951 "syn 2.0.119",
8952]
8953
8954[[package]]
89556085name = "primefield"
89566086version = "0.14.0"
89576087source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -9030,25 +6160,6 @@
90306160]
90316161
90326162[[package]]
9033name = "profiling"
9034version = "1.0.18"
9035source = "registry+https://github.com/rust-lang/crates.io-index"
9036checksum = "3d595e54a326bc53c1c197b32d295e14b169e3cfeaa8dc82b529f947fba6bcf5"
9037dependencies = [
9038 "profiling-procmacros",
9039]
9040
9041[[package]]
9042name = "profiling-procmacros"
9043version = "1.0.18"
9044source = "registry+https://github.com/rust-lang/crates.io-index"
9045checksum = "4488a4a36b9a4ba6b9334a32a39971f77c1436ec82c38707bce707699cc3bbcb"
9046dependencies = [
9047 "quote",
9048 "syn 2.0.119",
9049]
9050
9051[[package]]
90526163name = "prost"
90536164version = "0.14.4"
90546165source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -9059,25 +6170,6 @@
90596170]
90606171
90616172[[package]]
9062name = "prost-build"
9063version = "0.14.4"
9064source = "registry+https://github.com/rust-lang/crates.io-index"
9065checksum = "03da047801ff44bb6a4d407d4860c05fd70bb81714e6b2f3812603d5b145b042"
9066dependencies = [
9067 "heck 0.5.0",
9068 "itertools 0.14.0",
9069 "log 0.4.33",
9070 "multimap",
9071 "petgraph",
9072 "prettyplease",
9073 "prost",
9074 "prost-types",
9075 "regex",
9076 "syn 2.0.119",
9077 "tempfile",
9078]
9079
9080[[package]]
90816173name = "prost-derive"
90826174version = "0.14.4"
90836175source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -9091,15 +6183,6 @@
90916183]
90926184
90936185[[package]]
9094name = "prost-types"
9095version = "0.14.4"
9096source = "registry+https://github.com/rust-lang/crates.io-index"
9097checksum = "f94967dc7688f3054c7fac87473ffae4cc4c3904800e2d9f5b857246d8963b0a"
9098dependencies = [
9099 "prost",
9100]
9101
9102[[package]]
91036186name = "psm"
91046187version = "0.1.32"
91056188source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -9115,16 +6198,7 @@
91156198source = "registry+https://github.com/rust-lang/crates.io-index"
91166199checksum = "0738ccf7ea06b608c10564b31debd4f5bc5e197fc8bfe088f68ae5ce81e7a4f1"
91176200dependencies = [
9118 "ptr_meta_derive 0.1.4",
9119]
9120
9121[[package]]
9122name = "ptr_meta"
9123version = "0.3.2"
9124source = "registry+https://github.com/rust-lang/crates.io-index"
9125checksum = "743da816b98c921cdbe8628ef7381b76f25ecf4da599fc80aca90eae7ef70cc0"
9126dependencies = [
9127 "ptr_meta_derive 0.3.2",
6201 "ptr_meta_derive",
91286202]
91296203
91306204[[package]]
@@ -9139,17 +6213,6 @@
91396213]
91406214
91416215[[package]]
9142name = "ptr_meta_derive"
9143version = "0.3.2"
9144source = "registry+https://github.com/rust-lang/crates.io-index"
9145checksum = "1c8d9ca532f185d5d4db7a7c9d51420b452168ea1c2b913953281bd6fe1fcbd0"
9146dependencies = [
9147 "proc-macro2",
9148 "quote",
9149 "syn 3.0.3",
9150]
9151
9152[[package]]
91536216name = "pulldown-cmark"
91546217version = "0.13.4"
91556218source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -9190,50 +6253,6 @@
91906253]
91916254
91926255[[package]]
9193name = "pulp"
9194version = "0.22.3"
9195source = "registry+https://github.com/rust-lang/crates.io-index"
9196checksum = "046aa45b989642ec2e4717c8e72d677b13edd831a4d3b6cf37d9a3e54912496a"
9197dependencies = [
9198 "bytemuck",
9199 "cfg-if",
9200 "libm",
9201 "num-complex",
9202 "paste",
9203 "pulp-wasm-simd-flag",
9204 "raw-cpuid",
9205 "reborrow",
9206 "version_check 0.9.5",
9207]
9208
9209[[package]]
9210name = "pulp-wasm-simd-flag"
9211version = "0.1.1"
9212source = "registry+https://github.com/rust-lang/crates.io-index"
9213checksum = "1d8f70e07b9c3962945a74e59ca1c511bba65b6419468acc217c457d93f3c740"
9214
9215[[package]]
9216name = "pxfm"
9217version = "0.1.30"
9218source = "registry+https://github.com/rust-lang/crates.io-index"
9219checksum = "d55d956fa96f5ec02be2e13af0e20391a5aa83d6a074e3ad368959d0fab299ea"
9220
9221[[package]]
9222name = "qoi"
9223version = "0.4.1"
9224source = "registry+https://github.com/rust-lang/crates.io-index"
9225checksum = "7f6d64c71eb498fe9eae14ce4ec935c555749aef511cca85b5568910d6e48001"
9226dependencies = [
9227 "bytemuck",
9228]
9229
9230[[package]]
9231name = "quick-error"
9232version = "2.0.1"
9233source = "registry+https://github.com/rust-lang/crates.io-index"
9234checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
9235
9236[[package]]
92376256name = "quick-xml"
92386257version = "0.28.2"
92396258source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -9269,7 +6288,6 @@
92696288source = "registry+https://github.com/rust-lang/crates.io-index"
92706289checksum = "04759210543be93709136e28212294a659ef5001836ff4eab4d663e4529bba83"
92716290dependencies = [
9272 "aws-lc-rs",
92736291 "bytes",
92746292 "getrandom 0.4.3",
92756293 "lru-slab",
@@ -9334,15 +6352,6 @@
93346352checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
93356353
93366354[[package]]
9337name = "rancor"
9338version = "0.1.3"
9339source = "registry+https://github.com/rust-lang/crates.io-index"
9340checksum = "9b534442d0fcdb55d66f373d9cac6d33b6293a2335bc2136dbd06ce0e87d2572"
9341dependencies = [
9342 "ptr_meta 0.3.2",
9343]
9344
9345[[package]]
93466355name = "rand"
93476356version = "0.7.3"
93486357source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -9380,235 +6389,95 @@
93806389name = "rand"
93816390version = "0.10.2"
93826391source = "registry+https://github.com/rust-lang/crates.io-index"
9383checksum = "c7f5fa3a058cd35567ef9bfa5e75732bee0f9e4c55fa90477bef2dfcdbc4be80"
9384dependencies = [
9385 "chacha20",
9386 "getrandom 0.4.3",
9387 "rand_core 0.10.1",
9388]
9389
9390[[package]]
9391name = "rand_chacha"
9392version = "0.2.2"
9393source = "registry+https://github.com/rust-lang/crates.io-index"
9394checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
9395dependencies = [
9396 "ppv-lite86",
9397 "rand_core 0.5.1",
9398]
9399
9400[[package]]
9401name = "rand_chacha"
9402version = "0.3.1"
9403source = "registry+https://github.com/rust-lang/crates.io-index"
9404checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
9405dependencies = [
9406 "ppv-lite86",
9407 "rand_core 0.6.4",
9408]
9409
9410[[package]]
9411name = "rand_chacha"
9412version = "0.9.0"
9413source = "registry+https://github.com/rust-lang/crates.io-index"
9414checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
9415dependencies = [
9416 "ppv-lite86",
9417 "rand_core 0.9.5",
9418]
9419
9420[[package]]
9421name = "rand_core"
9422version = "0.5.1"
9423source = "registry+https://github.com/rust-lang/crates.io-index"
9424checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
9425dependencies = [
9426 "getrandom 0.1.16",
9427]
9428
9429[[package]]
9430name = "rand_core"
9431version = "0.6.4"
9432source = "registry+https://github.com/rust-lang/crates.io-index"
9433checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
9434dependencies = [
9435 "getrandom 0.2.17",
9436]
9437
9438[[package]]
9439name = "rand_core"
9440version = "0.9.5"
9441source = "registry+https://github.com/rust-lang/crates.io-index"
9442checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
9443dependencies = [
9444 "getrandom 0.3.4",
9445]
9446
9447[[package]]
9448name = "rand_core"
9449version = "0.10.1"
9450source = "registry+https://github.com/rust-lang/crates.io-index"
9451checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"
9452
9453[[package]]
9454name = "rand_distr"
9455version = "0.5.1"
9456source = "registry+https://github.com/rust-lang/crates.io-index"
9457checksum = "6a8615d50dcf34fa31f7ab52692afec947c4dd0ab803cc87cb3b0b4570ff7463"
9458dependencies = [
9459 "num-traits",
9460 "rand 0.9.5",
9461]
9462
9463[[package]]
9464name = "rand_hc"
9465version = "0.2.0"
9466source = "registry+https://github.com/rust-lang/crates.io-index"
9467checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
9468dependencies = [
9469 "rand_core 0.5.1",
9470]
9471
9472[[package]]
9473name = "rand_pcg"
9474version = "0.10.2"
9475source = "registry+https://github.com/rust-lang/crates.io-index"
9476checksum = "caa0f4137e1c0a72f4c651489402276c8e8e1cf081f3b0ba156d2cbeef09e86a"
6392checksum = "c7f5fa3a058cd35567ef9bfa5e75732bee0f9e4c55fa90477bef2dfcdbc4be80"
94776393dependencies = [
6394 "chacha20",
6395 "getrandom 0.4.3",
94786396 "rand_core 0.10.1",
94796397]
94806398
94816399[[package]]
9482name = "rand_xoshiro"
9483version = "0.7.0"
6400name = "rand_chacha"
6401version = "0.2.2"
94846402source = "registry+https://github.com/rust-lang/crates.io-index"
9485checksum = "f703f4665700daf5512dcca5f43afa6af89f09db47fb56be587f80636bda2d41"
6403checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
94866404dependencies = [
9487 "rand_core 0.9.5",
6405 "ppv-lite86",
6406 "rand_core 0.5.1",
94886407]
94896408
94906409[[package]]
9491name = "random_word"
9492version = "0.5.2"
6410name = "rand_chacha"
6411version = "0.3.1"
94936412source = "registry+https://github.com/rust-lang/crates.io-index"
9494checksum = "e47a395bdb55442b883c89062d6bcff25dc90fa5f8369af81e0ac6d49d78cf81"
6413checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
94956414dependencies = [
9496 "ahash 0.8.12",
9497 "brotli",
9498 "paste",
9499 "rand 0.9.5",
9500 "unicase 2.9.0",
6415 "ppv-lite86",
6416 "rand_core 0.6.4",
95016417]
95026418
95036419[[package]]
9504name = "rangemap"
9505version = "1.8.0"
6420name = "rand_chacha"
6421version = "0.9.0"
95066422source = "registry+https://github.com/rust-lang/crates.io-index"
9507checksum = "a611d15b50743feb4c76b7d03edcb0e64f399c26961e4efe6975bc398be6aa3d"
6423checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
6424dependencies = [
6425 "ppv-lite86",
6426 "rand_core 0.9.5",
6427]
95086428
95096429[[package]]
9510name = "rav1e"
9511version = "0.8.1"
6430name = "rand_core"
6431version = "0.5.1"
95126432source = "registry+https://github.com/rust-lang/crates.io-index"
9513checksum = "43b6dd56e85d9483277cde964fd1bdb0428de4fec5ebba7540995639a21cb32b"
6433checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
95146434dependencies = [
9515 "aligned-vec",
9516 "arbitrary",
9517 "arg_enum_proc_macro",
9518 "arrayvec",
9519 "av-scenechange",
9520 "av1-grain",
9521 "bitstream-io",
9522 "built",
9523 "cfg-if",
9524 "interpolate_name",
9525 "itertools 0.14.0",
9526 "libc",
9527 "libfuzzer-sys",
9528 "log 0.4.33",
9529 "maybe-rayon",
9530 "new_debug_unreachable",
9531 "noop_proc_macro",
9532 "num-derive",
9533 "num-traits",
9534 "paste",
9535 "profiling",
9536 "rand 0.9.5",
9537 "rand_chacha 0.9.0",
9538 "simd_helpers",
9539 "thiserror 2.0.20",
9540 "v_frame",
9541 "wasm-bindgen",
6435 "getrandom 0.1.16",
95426436]
95436437
95446438[[package]]
9545name = "ravif"
9546version = "0.13.0"
6439name = "rand_core"
6440version = "0.6.4"
95476441source = "registry+https://github.com/rust-lang/crates.io-index"
9548checksum = "e52310197d971b0f5be7fe6b57530dcd27beb35c1b013f29d66c1ad73fbbcc45"
6442checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
95496443dependencies = [
9550 "avif-serialize",
9551 "imgref",
9552 "loop9",
9553 "quick-error",
9554 "rav1e",
9555 "rayon",
9556 "rgb",
6444 "getrandom 0.2.17",
95576445]
95586446
95596447[[package]]
9560name = "raw-cpuid"
9561version = "11.6.0"
6448name = "rand_core"
6449version = "0.9.5"
95626450source = "registry+https://github.com/rust-lang/crates.io-index"
9563checksum = "498cd0dc59d73224351ee52a95fee0f1a617a2eae0e7d9d720cc622c73a54186"
6451checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
95646452dependencies = [
9565 "bitflags 2.13.1",
6453 "getrandom 0.3.4",
95666454]
95676455
95686456[[package]]
9569name = "rawpointer"
9570version = "0.2.1"
6457name = "rand_core"
6458version = "0.10.1"
95716459source = "registry+https://github.com/rust-lang/crates.io-index"
9572checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3"
6460checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"
95736461
95746462[[package]]
9575name = "rayon"
9576version = "1.12.0"
6463name = "rand_hc"
6464version = "0.2.0"
95776465source = "registry+https://github.com/rust-lang/crates.io-index"
9578checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d"
6466checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
95796467dependencies = [
9580 "either",
9581 "rayon-core",
6468 "rand_core 0.5.1",
95826469]
95836470
95846471[[package]]
9585name = "rayon-cond"
9586version = "0.4.0"
6472name = "rand_pcg"
6473version = "0.10.2"
95876474source = "registry+https://github.com/rust-lang/crates.io-index"
9588checksum = "2964d0cf57a3e7a06e8183d14a8b527195c706b7983549cd5462d5aa3747438f"
6475checksum = "caa0f4137e1c0a72f4c651489402276c8e8e1cf081f3b0ba156d2cbeef09e86a"
95896476dependencies = [
9590 "either",
9591 "itertools 0.14.0",
9592 "rayon",
9593]
9594
9595[[package]]
9596name = "rayon-core"
9597version = "1.13.0"
9598source = "registry+https://github.com/rust-lang/crates.io-index"
9599checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
9600dependencies = [
9601 "crossbeam-deque",
9602 "crossbeam-utils",
6477 "rand_core 0.10.1",
96036478]
96046479
96056480[[package]]
9606name = "reborrow"
9607version = "0.5.5"
9608source = "registry+https://github.com/rust-lang/crates.io-index"
9609checksum = "03251193000f4bd3b042892be858ee50e8b3719f2b08e5833ac4353724632430"
9610
9611[[package]]
96126481name = "redis"
96136482version = "1.6.0"
96146483source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -9660,37 +6529,6 @@
96606529]
96616530
96626531[[package]]
9663name = "redox_users"
9664version = "0.5.2"
9665source = "registry+https://github.com/rust-lang/crates.io-index"
9666checksum = "a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac"
9667dependencies = [
9668 "getrandom 0.2.17",
9669 "libredox",
9670 "thiserror 2.0.20",
9671]
9672
9673[[package]]
9674name = "ref-cast"
9675version = "1.0.27"
9676source = "registry+https://github.com/rust-lang/crates.io-index"
9677checksum = "7e440fb4e4b4147295338efb76001ab9e4efc0e5839df2c47fc5ac2381d365c3"
9678dependencies = [
9679 "ref-cast-impl",
9680]
9681
9682[[package]]
9683name = "ref-cast-impl"
9684version = "1.0.27"
9685source = "registry+https://github.com/rust-lang/crates.io-index"
9686checksum = "92ecd8964f8453721699a1ed72037b0db49ce2f5a5138486ee89bed6f67cdf3a"
9687dependencies = [
9688 "proc-macro2",
9689 "quote",
9690 "syn 3.0.3",
9691]
9692
9693[[package]]
96946532name = "regex"
96956533version = "1.13.1"
96966534source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -9725,16 +6563,7 @@
97256563source = "registry+https://github.com/rust-lang/crates.io-index"
97266564checksum = "71fe3824f5629716b1589be05dacd749f6aa084c87e00e016714a8cdfccc997c"
97276565dependencies = [
9728 "bytecheck 0.6.12",
9729]
9730
9731[[package]]
9732name = "rend"
9733version = "0.5.4"
9734source = "registry+https://github.com/rust-lang/crates.io-index"
9735checksum = "663ba70707f96e871406fe10d68128412e619b06d1d47cb91c3a4c6501176240"
9736dependencies = [
9737 "bytecheck 0.8.3",
6566 "bytecheck",
97386567]
97396568
97406569[[package]]
@@ -9745,10 +6574,7 @@
97456574dependencies = [
97466575 "base64 0.22.1",
97476576 "bytes",
9748 "encoding_rs",
97496577 "futures-core",
9750 "futures-util",
9751 "h2 0.4.19",
97526578 "http 1.5.0",
97536579 "http-body 1.1.0",
97546580 "http-body-util",
@@ -9757,13 +6583,10 @@
97576583 "hyper-util",
97586584 "js-sys",
97596585 "log 0.4.33",
9760 "mime 0.3.17",
9761 "mime_guess",
97626586 "percent-encoding 2.3.2",
97636587 "pin-project-lite",
97646588 "quinn",
97656589 "rustls",
9766 "rustls-native-certs",
97676590 "rustls-pki-types",
97686591 "serde",
97696592 "serde_json",
@@ -9771,16 +6594,14 @@
97716594 "sync_wrapper",
97726595 "tokio",
97736596 "tokio-rustls",
9774 "tokio-util",
97756597 "tower",
97766598 "tower-http 0.6.11",
97776599 "tower-service",
97786600 "url 2.5.8",
97796601 "wasm-bindgen",
97806602 "wasm-bindgen-futures",
9781 "wasm-streams 0.4.2",
97826603 "web-sys",
9783 "webpki-roots 1.0.9",
6604 "webpki-roots",
97846605]
97856606
97866607[[package]]
@@ -9791,41 +6612,26 @@
97916612dependencies = [
97926613 "base64 0.22.1",
97936614 "bytes",
9794 "encoding_rs",
97956615 "futures-channel",
97966616 "futures-core",
97976617 "futures-util",
9798 "h2 0.4.19",
97996618 "http 1.5.0",
98006619 "http-body 1.1.0",
98016620 "http-body-util",
98026621 "hyper 1.11.0",
9803 "hyper-rustls",
98046622 "hyper-util",
98056623 "js-sys",
98066624 "log 0.4.33",
9807 "mime 0.3.17",
9808 "mime_guess",
98096625 "percent-encoding 2.3.2",
98106626 "pin-project-lite",
9811 "quinn",
9812 "rustls",
9813 "rustls-pki-types",
9814 "rustls-platform-verifier",
9815 "serde",
9816 "serde_json",
9817 "serde_urlencoded",
98186627 "sync_wrapper",
98196628 "tokio",
9820 "tokio-rustls",
9821 "tokio-util",
98226629 "tower",
98236630 "tower-http 0.6.11",
98246631 "tower-service",
98256632 "url 2.5.8",
98266633 "wasm-bindgen",
98276634 "wasm-bindgen-futures",
9828 "wasm-streams 0.5.0",
98296635 "web-sys",
98306636]
98316637
@@ -9850,151 +6656,6 @@
98506656]
98516657
98526658[[package]]
9853name = "rgb"
9854version = "0.8.53"
9855source = "registry+https://github.com/rust-lang/crates.io-index"
9856checksum = "47b34b781b31e5d73e9fbc8689c70551fd1ade9a19e3e28cfec8580a79290cc4"
9857
9858[[package]]
9859name = "rig"
9860version = "0.42.0"
9861source = "registry+https://github.com/rust-lang/crates.io-index"
9862checksum = "b989f4060e5f3c1ea4b8b6999f6759949d820704286cc6976b7a688cc0133029"
9863dependencies = [
9864 "rig-agent",
9865 "rig-core",
9866 "rig-derive",
9867 "rig-fastembed",
9868 "rig-helixdb",
9869 "rig-lancedb",
9870 "rig-milvus",
9871]
9872
9873[[package]]
9874name = "rig-agent"
9875version = "0.42.0"
9876source = "registry+https://github.com/rust-lang/crates.io-index"
9877checksum = "b66477c0d0a786358d078e7e3541a73089dd9009100d6e2b3fe3b0d730e8550f"
9878dependencies = [
9879 "async-stream",
9880 "fastrand",
9881 "futures",
9882 "http 1.5.0",
9883 "indexmap 2.14.0",
9884 "rig-core",
9885 "rig-derive",
9886 "schemars 1.2.2",
9887 "serde",
9888 "serde_json",
9889 "thiserror 2.0.20",
9890 "tokio",
9891 "tracing",
9892 "tracing-futures",
9893]
9894
9895[[package]]
9896name = "rig-core"
9897version = "0.42.0"
9898source = "registry+https://github.com/rust-lang/crates.io-index"
9899checksum = "432d83e0facf16749f91fe729cbffca84437e8062d2f4e92f4f12e903693922d"
9900dependencies = [
9901 "as-any",
9902 "async-stream",
9903 "base64 0.22.1",
9904 "bytes",
9905 "eventsource-stream",
9906 "fastrand",
9907 "futures",
9908 "futures-timer",
9909 "glob",
9910 "http 1.5.0",
9911 "indexmap 2.14.0",
9912 "mime 0.3.17",
9913 "mime_guess",
9914 "ordered-float 5.5.0",
9915 "pin-project-lite",
9916 "reqwest 0.13.4",
9917 "rig-derive",
9918 "schemars 1.2.2",
9919 "serde",
9920 "serde_json",
9921 "sha2 0.10.9",
9922 "thiserror 2.0.20",
9923 "tokio",
9924 "tokio-tungstenite",
9925 "tracing",
9926 "tracing-futures",
9927 "url 2.5.8",
9928]
9929
9930[[package]]
9931name = "rig-derive"
9932version = "0.42.0"
9933source = "registry+https://github.com/rust-lang/crates.io-index"
9934checksum = "de0a33f1bac45f16e50146c248bcbbfaa44518c7252d274e972c7f4ad71aaba7"
9935dependencies = [
9936 "convert_case",
9937 "proc-macro-crate",
9938 "proc-macro2",
9939 "quote",
9940 "syn 2.0.119",
9941]
9942
9943[[package]]
9944name = "rig-fastembed"
9945version = "0.42.0"
9946source = "registry+https://github.com/rust-lang/crates.io-index"
9947checksum = "f1dff99f9bea13108bb14df5431b6fc0738beb87f1fe5ebfcf26ae9fe54a188d"
9948dependencies = [
9949 "fastembed",
9950 "rig-core",
9951 "schemars 1.2.2",
9952 "serde",
9953 "serde_json",
9954 "tracing",
9955]
9956
9957[[package]]
9958name = "rig-helixdb"
9959version = "0.42.0"
9960source = "registry+https://github.com/rust-lang/crates.io-index"
9961checksum = "b5fa2b188a1e9e65d29c34738c97465f0822c57540d6d45fd4f04dad906c966a"
9962dependencies = [
9963 "reqwest 0.13.4",
9964 "rig-core",
9965 "serde",
9966 "serde_json",
9967 "thiserror 2.0.20",
9968]
9969
9970[[package]]
9971name = "rig-lancedb"
9972version = "0.42.0"
9973source = "registry+https://github.com/rust-lang/crates.io-index"
9974checksum = "c5fe3555202c5bd4e30948414c2e234fddd9260d4520046733fcf0d58718f3a1"
9975dependencies = [
9976 "arrow-array",
9977 "futures",
9978 "lancedb",
9979 "rig-core",
9980 "serde",
9981 "serde_json",
9982]
9983
9984[[package]]
9985name = "rig-milvus"
9986version = "0.42.0"
9987source = "registry+https://github.com/rust-lang/crates.io-index"
9988checksum = "af9c7b7ff7ed9c16da983a21f1e81f425c9805355427a92f4d2d97ba1fe2aa12"
9989dependencies = [
9990 "reqwest 0.13.4",
9991 "rig-core",
9992 "serde",
9993 "serde_json",
9994 "uuid",
9995]
9996
9997[[package]]
99986659name = "ring"
99996660version = "0.17.14"
100006661source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -10015,37 +6676,18 @@
100156676checksum = "2297bf9c81a3f0dc96bc9521370b88f054168c29826a75e89c55ff196e7ed6a1"
100166677dependencies = [
100176678 "bitvec",
10018 "bytecheck 0.6.12",
6679 "bytecheck",
100196680 "bytes",
100206681 "hashbrown 0.12.3",
10021 "ptr_meta 0.1.4",
10022 "rend 0.4.2",
10023 "rkyv_derive 0.7.46",
6682 "ptr_meta",
6683 "rend",
6684 "rkyv_derive",
100246685 "seahash",
100256686 "tinyvec",
100266687 "uuid",
100276688]
100286689
100296690[[package]]
10030name = "rkyv"
10031version = "0.8.18"
10032source = "registry+https://github.com/rust-lang/crates.io-index"
10033checksum = "d9776093b7ca170454ab1406954f7b7d97a57c51dc6c0642957fb2ef25c2d399"
10034dependencies = [
10035 "bytecheck 0.8.3",
10036 "bytes",
10037 "hashbrown 0.17.1",
10038 "indexmap 2.14.0",
10039 "munge",
10040 "ptr_meta 0.3.2",
10041 "rancor",
10042 "rend 0.5.4",
10043 "rkyv_derive 0.8.18",
10044 "tinyvec",
10045 "uuid",
10046]
10047
10048[[package]]
100496691name = "rkyv_derive"
100506692version = "0.7.46"
100516693source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -10057,27 +6699,6 @@
100576699]
100586700
100596701[[package]]
10060name = "rkyv_derive"
10061version = "0.8.18"
10062source = "registry+https://github.com/rust-lang/crates.io-index"
10063checksum = "1c25ef604ac7dd839d44d64648952ea23c97866f124ff671b0ed2cf3ad9bb06e"
10064dependencies = [
10065 "proc-macro2",
10066 "quote",
10067 "syn 3.0.3",
10068]
10069
10070[[package]]
10071name = "roaring"
10072version = "0.11.5"
10073source = "registry+https://github.com/rust-lang/crates.io-index"
10074checksum = "18bd8a37d17a58532776dcdf6041ce64929adca78e8489d5cacbafe99229d3e1"
10075dependencies = [
10076 "bytemuck",
10077 "byteorder",
10078]
10079
10080[[package]]
100816702name = "rsa"
100826703version = "0.9.10"
100836704source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -10133,13 +6754,13 @@
101336754 "cipher 0.5.2",
101346755 "crypto-bigint 0.7.5",
101356756 "ctr 0.10.1",
10136 "curve25519-dalek 5.0.0",
6757 "curve25519-dalek",
101376758 "data-encoding",
101386759 "delegate",
101396760 "der 0.8.1",
101406761 "digest 0.11.3",
101416762 "ecdsa 0.17.0",
10142 "ed25519-dalek 3.0.0",
6763 "ed25519-dalek",
101436764 "elliptic-curve 0.14.1",
101446765 "enum_dispatch",
101456766 "flate2",
@@ -10295,16 +6916,6 @@
102956916]
102966917
102976918[[package]]
10298name = "rust-stemmers"
10299version = "1.2.0"
10300source = "registry+https://github.com/rust-lang/crates.io-index"
10301checksum = "e46a2036019fdb888131db7a4c847a1063a7493f971ed94ea82c67eada63ca54"
10302dependencies = [
10303 "serde",
10304 "serde_derive",
10305]
10306
10307[[package]]
103086919name = "rust_decimal"
103096920version = "1.42.1"
103106921source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -10315,7 +6926,7 @@
103156926 "bytes",
103166927 "num-traits",
103176928 "rand 0.8.7",
10318 "rkyv 0.7.46",
6929 "rkyv",
103196930 "serde",
103206931 "serde_json",
103216932 "wasm-bindgen",
@@ -10355,7 +6966,6 @@
103556966source = "registry+https://github.com/rust-lang/crates.io-index"
103566967checksum = "0283386ce02abc0151e1761d08802dfe86c173b0b494af5cbc086574e453da06"
103576968dependencies = [
10358 "aws-lc-rs",
103596969 "log 0.4.33",
103606970 "once_cell",
103616971 "ring",
@@ -10388,39 +6998,11 @@
103886998]
103896999
103907000[[package]]
10391name = "rustls-platform-verifier"
10392version = "0.7.0"
10393source = "registry+https://github.com/rust-lang/crates.io-index"
10394checksum = "26d1e2536ce4f35f4846aa13bff16bd0ff40157cdb14cc056c7b14ba41233ba0"
10395dependencies = [
10396 "core-foundation 0.10.1",
10397 "core-foundation-sys",
10398 "jni",
10399 "log 0.4.33",
10400 "once_cell",
10401 "rustls",
10402 "rustls-native-certs",
10403 "rustls-platform-verifier-android",
10404 "rustls-webpki",
10405 "security-framework",
10406 "security-framework-sys",
10407 "webpki-root-certs",
10408 "windows-sys 0.61.2",
10409]
10410
10411[[package]]
10412name = "rustls-platform-verifier-android"
10413version = "0.1.1"
10414source = "registry+https://github.com/rust-lang/crates.io-index"
10415checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f"
10416
10417[[package]]
104187001name = "rustls-webpki"
104197002version = "0.103.14"
104207003source = "registry+https://github.com/rust-lang/crates.io-index"
104217004checksum = "0527518605e68109d875e248ea259b6758801cf165e4b2c2733ae3b51f12535a"
104227005dependencies = [
10423 "aws-lc-rs",
104247006 "ring",
104257007 "rustls-pki-types",
104267008 "untrusted 0.9.0",
@@ -10490,49 +7072,6 @@
104907072]
104917073
104927074[[package]]
10493name = "schemars"
10494version = "0.9.0"
10495source = "registry+https://github.com/rust-lang/crates.io-index"
10496checksum = "4cd191f9397d57d581cddd31014772520aa448f65ef991055d7f61582c65165f"
10497dependencies = [
10498 "dyn-clone",
10499 "ref-cast",
10500 "serde",
10501 "serde_json",
10502]
10503
10504[[package]]
10505name = "schemars"
10506version = "1.2.2"
10507source = "registry+https://github.com/rust-lang/crates.io-index"
10508checksum = "687274d293b6cdc6e73e0fee520bf2049650090d7164f87672d212a3c530cf4a"
10509dependencies = [
10510 "dyn-clone",
10511 "ref-cast",
10512 "schemars_derive",
10513 "serde",
10514 "serde_json",
10515]
10516
10517[[package]]
10518name = "schemars_derive"
10519version = "1.2.2"
10520source = "registry+https://github.com/rust-lang/crates.io-index"
10521checksum = "d98c67716b46af2f0b8cf752abc930f6f9aecfbf671ecfb531db8a31dbe4e2ba"
10522dependencies = [
10523 "proc-macro2",
10524 "quote",
10525 "serde_derive_internals",
10526 "syn 3.0.3",
10527]
10528
10529[[package]]
10530name = "scoped-tls"
10531version = "1.0.1"
10532source = "registry+https://github.com/rust-lang/crates.io-index"
10533checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
10534
10535[[package]]
105367075name = "scopeguard"
105377076version = "1.2.0"
105387077source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -10634,7 +7173,7 @@
106347173checksum = "546040c653a705e60ec65ecd3191a809603734bebbc225775916dea9ae409b31"
106357174dependencies = [
106367175 "chrono",
10637 "ordered-float 4.6.0",
7176 "ordered-float",
106387177 "rust_decimal",
106397178 "sea-query-derive",
106407179 "serde_json",
@@ -10732,7 +7271,7 @@
107327271checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d"
107337272dependencies = [
107347273 "bitflags 2.13.1",
10735 "core-foundation 0.10.1",
7274 "core-foundation",
107367275 "core-foundation-sys",
107377276 "libc",
107387277 "security-framework-sys",
@@ -10755,18 +7294,6 @@
107557294checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
107567295
107577296[[package]]
10758name = "send_wrapper"
10759version = "0.6.0"
10760source = "registry+https://github.com/rust-lang/crates.io-index"
10761checksum = "cd0b0ec5f1c1ca621c432a25813d8d60c88abe6d3e08a3eb9cf37d97a0fe3d73"
10762
10763[[package]]
10764name = "seq-macro"
10765version = "0.3.6"
10766source = "registry+https://github.com/rust-lang/crates.io-index"
10767checksum = "1bc711410fbe7399f390ca1c3b60ad0f53f80e95c5eb935e52268a0e2cd49acc"
10768
10769[[package]]
107707297name = "serde"
107717298version = "1.0.229"
107727299source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -10797,17 +7324,6 @@
107977324]
107987325
107997326[[package]]
10800name = "serde_derive_internals"
10801version = "0.30.0"
10802source = "registry+https://github.com/rust-lang/crates.io-index"
10803checksum = "f852137cce035d6a4df67ccce505ff6b3e9fd3a10e3e52b24dc71e650bb1a9bd"
10804dependencies = [
10805 "proc-macro2",
10806 "quote",
10807 "syn 3.0.3",
10808]
10809
10810[[package]]
108117327name = "serde_json"
108127328version = "1.0.151"
108137329source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -10821,15 +7337,6 @@
108217337]
108227338
108237339[[package]]
10824name = "serde_nanos"
10825version = "0.1.4"
10826source = "registry+https://github.com/rust-lang/crates.io-index"
10827checksum = "a93142f0367a4cc53ae0fead1bcda39e85beccfad3dcd717656cacab94b12985"
10828dependencies = [
10829 "serde",
10830]
10831
10832[[package]]
108337340name = "serde_path_to_error"
108347341version = "0.1.20"
108357342source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -10841,17 +7348,6 @@
108417348]
108427349
108437350[[package]]
10844name = "serde_repr"
10845version = "0.1.21"
10846source = "registry+https://github.com/rust-lang/crates.io-index"
10847checksum = "8d3b1629de253c70a0508c3899572da79ca359fdab27c7920ff00406df418906"
10848dependencies = [
10849 "proc-macro2",
10850 "quote",
10851 "syn 3.0.3",
10852]
10853
10854[[package]]
108557351name = "serde_spanned"
108567352version = "0.6.9"
108577353source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -10884,52 +7380,6 @@
108847380]
108857381
108867382[[package]]
10887name = "serde_with"
10888version = "3.23.0"
10889source = "registry+https://github.com/rust-lang/crates.io-index"
10890checksum = "935177bb8c0cd8ca1a4e6d1a2ac8988bea69cab4f9d3a31311e012ad27868ea4"
10891dependencies = [
10892 "base64 0.23.1",
10893 "bs58",
10894 "chrono",
10895 "hex",
10896 "indexmap 1.9.3",
10897 "indexmap 2.14.0",
10898 "jiff",
10899 "schemars 0.9.0",
10900 "schemars 1.2.2",
10901 "serde_core",
10902 "serde_json",
10903 "serde_with_macros",
10904 "time 0.3.55",
10905]
10906
10907[[package]]
10908name = "serde_with_macros"
10909version = "3.23.0"
10910source = "registry+https://github.com/rust-lang/crates.io-index"
10911checksum = "1d607aa01a3cb0ad757d6fd216136910db3c97b102fe686585689615a02dbcdc"
10912dependencies = [
10913 "darling 0.24.1",
10914 "proc-macro2",
10915 "quote",
10916 "syn 3.0.3",
10917]
10918
10919[[package]]
10920name = "serde_yaml_ng"
10921version = "0.10.0"
10922source = "registry+https://github.com/rust-lang/crates.io-index"
10923checksum = "7b4db627b98b36d4203a7b458cf3573730f2bb591b28871d916dfa9efabfd41f"
10924dependencies = [
10925 "indexmap 2.14.0",
10926 "itoa",
10927 "ryu",
10928 "serde",
10929 "unsafe-libyaml",
10930]
10931
10932[[package]]
109337383name = "serdect"
109347384version = "0.4.3"
109357385source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -11081,18 +7531,6 @@
110817531]
110827532
110837533[[package]]
11084name = "signatory"
11085version = "0.27.1"
11086source = "registry+https://github.com/rust-lang/crates.io-index"
11087checksum = "c1e303f8205714074f6068773f0e29527e0453937fe837c9717d066635b65f31"
11088dependencies = [
11089 "pkcs8 0.10.2",
11090 "rand_core 0.6.4",
11091 "signature 2.2.0",
11092 "zeroize",
11093]
11094
11095[[package]]
110967534name = "signature"
110977535version = "2.2.0"
110987536source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -11119,37 +7557,12 @@
111197557checksum = "3a219298ac11a56ea9a6d2120044824d6f01aeb034955e7af7bc16858527deea"
111207558
111217559[[package]]
11122name = "simd_cesu8"
11123version = "1.2.0"
11124source = "registry+https://github.com/rust-lang/crates.io-index"
11125checksum = "11031e251abf8611c80f460e19dbdeb54a66db918e49c65a7065b46ac7aec520"
11126dependencies = [
11127 "rustc_version",
11128 "simdutf8",
11129]
11130
11131[[package]]
11132name = "simd_helpers"
11133version = "0.1.0"
11134source = "registry+https://github.com/rust-lang/crates.io-index"
11135checksum = "95890f873bec569a0362c235787f3aca6e1e887302ba4840839bcc6459c42da6"
11136dependencies = [
11137 "quote",
11138]
11139
11140[[package]]
111417560name = "simdutf8"
111427561version = "0.1.5"
111437562source = "registry+https://github.com/rust-lang/crates.io-index"
111447563checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e"
111457564
111467565[[package]]
11147name = "siphasher"
11148version = "1.0.3"
11149source = "registry+https://github.com/rust-lang/crates.io-index"
11150checksum = "8ee5873ec9cce0195efcb7a4e9507a04cd49aec9c83d0389df45b1ef7ba2e649"
11151
11152[[package]]
111537566name = "slab"
111547567version = "0.4.12"
111557568source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -11182,48 +7595,6 @@
111827595]
111837596
111847597[[package]]
11185name = "snafu"
11186version = "0.8.9"
11187source = "registry+https://github.com/rust-lang/crates.io-index"
11188checksum = "6e84b3f4eacbf3a1ce05eac6763b4d629d60cbc94d632e4092c54ade71f1e1a2"
11189dependencies = [
11190 "snafu-derive 0.8.9",
11191]
11192
11193[[package]]
11194name = "snafu"
11195version = "0.9.2"
11196source = "registry+https://github.com/rust-lang/crates.io-index"
11197checksum = "e45cb604038abb7b926b679887b3226d8d0f23874b66623625a0454be425a4b7"
11198dependencies = [
11199 "snafu-derive 0.9.2",
11200]
11201
11202[[package]]
11203name = "snafu-derive"
11204version = "0.8.9"
11205source = "registry+https://github.com/rust-lang/crates.io-index"
11206checksum = "c1c97747dbf44bb1ca44a561ece23508e99cb592e862f22222dcf42f51d1e451"
11207dependencies = [
11208 "heck 0.5.0",
11209 "proc-macro2",
11210 "quote",
11211 "syn 2.0.119",
11212]
11213
11214[[package]]
11215name = "snafu-derive"
11216version = "0.9.2"
11217source = "registry+https://github.com/rust-lang/crates.io-index"
11218checksum = "287f59010008f0d7cf5e3b03196d666c1acc46c8d3e9cf34c28a1a7157601e72"
11219dependencies = [
11220 "heck 0.5.0",
11221 "proc-macro2",
11222 "quote",
11223 "syn 2.0.119",
11224]
11225
11226[[package]]
112277598name = "socket2"
112287599version = "0.5.10"
112297600source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -11244,17 +7615,6 @@
112447615]
112457616
112467617[[package]]
11247name = "socks"
11248version = "0.3.4"
11249source = "registry+https://github.com/rust-lang/crates.io-index"
11250checksum = "f0c3dbbd9ae980613c6dd8e28a9407b50509d3803b57624d5dfe8315218cd58b"
11251dependencies = [
11252 "byteorder",
11253 "libc",
11254 "winapi",
11255]
11256
11257[[package]]
112587618name = "space"
112597619version = "1.0.0"
112607620dependencies = [
@@ -11307,45 +7667,12 @@
113077667]
113087668
113097669[[package]]
11310name = "spm_precompiled"
11311version = "0.1.4"
11312source = "registry+https://github.com/rust-lang/crates.io-index"
11313checksum = "5851699c4033c63636f7ea4cf7b7c1f1bf06d0cc03cfb42e711de5a5c46cf326"
11314dependencies = [
11315 "base64 0.13.1",
11316 "nom 7.1.3",
11317 "serde",
11318 "unicode-segmentation",
11319]
11320
11321[[package]]
113227670name = "sponge-cursor"
113237671version = "0.1.0"
113247672source = "registry+https://github.com/rust-lang/crates.io-index"
113257673checksum = "3a0219bd7d979d58245a4f41f695e1ac9f8befdffadd7f61f1bae9e39abc6620"
113267674
113277675[[package]]
11328name = "sqlparser"
11329version = "0.61.0"
11330source = "registry+https://github.com/rust-lang/crates.io-index"
11331checksum = "dbf5ea8d4d7c808e1af1cbabebca9a2abe603bcefc22294c5b95018d53200cb7"
11332dependencies = [
11333 "log 0.4.33",
11334 "sqlparser_derive",
11335]
11336
11337[[package]]
11338name = "sqlparser_derive"
11339version = "0.5.0"
11340source = "registry+https://github.com/rust-lang/crates.io-index"
11341checksum = "a6dd45d8fc1c79299bfbb7190e42ccbbdf6a5f52e4a6ad98d92357ea965bd289"
11342dependencies = [
11343 "proc-macro2",
11344 "quote",
11345 "syn 2.0.119",
11346]
11347
11348[[package]]
113497676name = "sqlx"
113507677version = "0.9.0"
113517678source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -11378,7 +7705,7 @@
113787705 "futures-util",
113797706 "hashbrown 0.16.1",
113807707 "hashlink",
11381 "indexmap 2.14.0",
7708 "indexmap",
113827709 "log 0.4.33",
113837710 "memchr",
113847711 "percent-encoding 2.3.2",
@@ -11395,7 +7722,7 @@
113957722 "tracing",
113967723 "url 2.5.8",
113977724 "uuid",
11398 "webpki-roots 1.0.9",
7725 "webpki-roots",
113997726]
114007727
114017728[[package]]
@@ -11488,7 +7815,7 @@
114887815 "hmac 0.13.0",
114897816 "itoa",
114907817 "log 0.4.33",
11491 "md-5 0.11.0",
7818 "md-5",
114927819 "memchr",
114937820 "rand 0.10.2",
114947821 "rust_decimal",
@@ -11615,7 +7942,7 @@
116157942 "argon2",
116167943 "bcrypt-pbkdf",
116177944 "ctutils",
11618 "ed25519-dalek 3.0.0",
7945 "ed25519-dalek",
116197946 "hex",
116207947 "hmac 0.13.0",
116217948 "p256 0.14.0",
@@ -11664,18 +7991,6 @@
116647991checksum = "d7beae5182595e9a8b683fa98c4317f956c9a2dec3b9716990d20023cc60c766"
116657992
116667993[[package]]
11667name = "std_prelude"
11668version = "0.2.12"
11669source = "registry+https://github.com/rust-lang/crates.io-index"
11670checksum = "8207e78455ffdf55661170876f88daf85356e4edd54e0a3dbc79586ca1e50cbe"
11671
11672[[package]]
11673name = "stfu8"
11674version = "0.2.7"
11675source = "registry+https://github.com/rust-lang/crates.io-index"
11676checksum = "e51f1e89f093f99e7432c491c382b88a6860a5adbe6bf02574bf0a08efff1978"
11677
11678[[package]]
116797994name = "storage"
116807995version = "1.0.0"
116817996dependencies = [
@@ -11707,15 +8022,6 @@
117078022
117088023[[package]]
117098024name = "strum"
11710version = "0.26.3"
11711source = "registry+https://github.com/rust-lang/crates.io-index"
11712checksum = "8fec0f0aef304996cf250b31b5a10dee7980c85da9d759361292b8bca5a18f06"
11713dependencies = [
11714 "strum_macros 0.26.4",
11715]
11716
11717[[package]]
11718name = "strum"
117198025version = "0.27.2"
117208026source = "registry+https://github.com/rust-lang/crates.io-index"
117218027checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf"
@@ -11728,9 +8034,6 @@
117288034version = "0.28.0"
117298035source = "registry+https://github.com/rust-lang/crates.io-index"
117308036checksum = "9628de9b8791db39ceda2b119bbe13134770b56c138ec1d3af810d045c04f9bd"
11731dependencies = [
11732 "strum_macros 0.28.0",
11733]
117348037
117358038[[package]]
117368039name = "strum_macros"
@@ -11747,19 +8050,6 @@
117478050
117488051[[package]]
117498052name = "strum_macros"
11750version = "0.26.4"
11751source = "registry+https://github.com/rust-lang/crates.io-index"
11752checksum = "4c6bee85a5a24955dc440386795aa378cd9cf82acd5f764469152d2270e581be"
11753dependencies = [
11754 "heck 0.5.0",
11755 "proc-macro2",
11756 "quote",
11757 "rustversion",
11758 "syn 2.0.119",
11759]
11760
11761[[package]]
11762name = "strum_macros"
117638053version = "0.27.2"
117648054source = "registry+https://github.com/rust-lang/crates.io-index"
117658055checksum = "7695ce3845ea4b33927c055a39dc438a45b059f7c1b3d91d38d10355fb8cbca7"
@@ -11771,18 +8061,6 @@
117718061]
117728062
117738063[[package]]
11774name = "strum_macros"
11775version = "0.28.0"
11776source = "registry+https://github.com/rust-lang/crates.io-index"
11777checksum = "ab85eea0270ee17587ed4156089e10b9e6880ee688791d45a905f5b1ca36f664"
11778dependencies = [
11779 "heck 0.5.0",
11780 "proc-macro2",
11781 "quote",
11782 "syn 2.0.119",
11783]
11784
11785[[package]]
117868064name = "subtle"
117878065version = "2.6.1"
117888066source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -11846,35 +8124,14 @@
118468124]
118478125
118488126[[package]]
11849name = "synstructure"
11850version = "0.13.2"
11851source = "registry+https://github.com/rust-lang/crates.io-index"
11852checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
11853dependencies = [
11854 "proc-macro2",
11855 "quote",
11856 "syn 2.0.119",
11857]
11858
11859[[package]]
11860name = "system-configuration"
11861version = "0.7.0"
11862source = "registry+https://github.com/rust-lang/crates.io-index"
11863checksum = "a13f3d0daba03132c0aa9767f98351b3488edc2c100cda2d2ec2b04f3d8d3c8b"
11864dependencies = [
11865 "bitflags 2.13.1",
11866 "core-foundation 0.9.4",
11867 "system-configuration-sys",
11868]
11869
11870[[package]]
11871name = "system-configuration-sys"
11872version = "0.6.0"
8127name = "synstructure"
8128version = "0.13.2"
118738129source = "registry+https://github.com/rust-lang/crates.io-index"
11874checksum = "8e1d1b10ced5ca923a1fcb8d03e96b8d3268065d724548c0211415ff6ac6bac4"
8130checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
118758131dependencies = [
11876 "core-foundation-sys",
11877 "libc",
8132 "proc-macro2",
8133 "quote",
8134 "syn 2.0.119",
118788135]
118798136
118808137[[package]]
@@ -11943,15 +8200,6 @@
119438200]
119448201
119458202[[package]]
11946name = "thread-tree"
11947version = "0.3.3"
11948source = "registry+https://github.com/rust-lang/crates.io-index"
11949checksum = "ffbd370cb847953a25954d9f63e14824a36113f8c72eecf6eccef5dc4b45d630"
11950dependencies = [
11951 "crossbeam-channel",
11952]
11953
11954[[package]]
119558203name = "thread_local"
119568204version = "1.1.10"
119578205source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -11961,20 +8209,6 @@
119618209]
119628210
119638211[[package]]
11964name = "tiff"
11965version = "0.11.3"
11966source = "registry+https://github.com/rust-lang/crates.io-index"
11967checksum = "b63feaf3343d35b6ca4d50483f94843803b0f51634937cc2ec519fc32232bc52"
11968dependencies = [
11969 "fax",
11970 "flate2",
11971 "half",
11972 "quick-error",
11973 "weezl",
11974 "zune-jpeg",
11975]
11976
11977[[package]]
119788212name = "time"
119798213version = "0.1.45"
119808214source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -12051,39 +8285,6 @@
120518285checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
120528286
120538287[[package]]
12054name = "tokenizers"
12055version = "0.21.4"
12056source = "registry+https://github.com/rust-lang/crates.io-index"
12057checksum = "a620b996116a59e184c2fa2dfd8251ea34a36d0a514758c6f966386bd2e03476"
12058dependencies = [
12059 "ahash 0.8.12",
12060 "aho-corasick",
12061 "compact_str",
12062 "dary_heap",
12063 "derive_builder",
12064 "esaxx-rs",
12065 "getrandom 0.3.4",
12066 "itertools 0.14.0",
12067 "log 0.4.33",
12068 "macro_rules_attribute",
12069 "monostate",
12070 "onig",
12071 "paste",
12072 "rand 0.9.5",
12073 "rayon",
12074 "rayon-cond",
12075 "regex",
12076 "regex-syntax",
12077 "serde",
12078 "serde_json",
12079 "spm_precompiled",
12080 "thiserror 2.0.20",
12081 "unicode-normalization-alignments",
12082 "unicode-segmentation",
12083 "unicode_categories",
12084]
12085
12086[[package]]
120878288name = "tokio"
120888289version = "1.53.1"
120898290source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -12140,7 +8341,6 @@
121408341 "futures-core",
121418342 "pin-project-lite",
121428343 "tokio",
12143 "tokio-util",
121448344]
121458345
121468346[[package]]
@@ -12151,12 +8351,8 @@
121518351dependencies = [
121528352 "futures-util",
121538353 "log 0.4.33",
12154 "rustls",
12155 "rustls-pki-types",
121568354 "tokio",
12157 "tokio-rustls",
121588355 "tungstenite",
12159 "webpki-roots 0.26.11",
121608356]
121618357
121628358[[package]]
@@ -12174,27 +8370,6 @@
121748370]
121758371
121768372[[package]]
12177name = "tokio-websockets"
12178version = "0.10.1"
12179source = "registry+https://github.com/rust-lang/crates.io-index"
12180checksum = "f591660438b3038dd04d16c938271c79e7e06260ad2ea2885a4861bfb238605d"
12181dependencies = [
12182 "base64 0.22.1",
12183 "bytes",
12184 "futures-core",
12185 "futures-sink",
12186 "http 1.5.0",
12187 "httparse",
12188 "rand 0.8.7",
12189 "ring",
12190 "rustls-pki-types",
12191 "tokio",
12192 "tokio-rustls",
12193 "tokio-util",
12194 "webpki-roots 0.26.11",
12195]
12196
12197[[package]]
121988373name = "toml"
121998374version = "0.8.23"
122008375source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -12230,7 +8405,7 @@
122308405source = "registry+https://github.com/rust-lang/crates.io-index"
122318406checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a"
122328407dependencies = [
12233 "indexmap 2.14.0",
8408 "indexmap",
122348409 "serde",
122358410 "serde_spanned",
122368411 "toml_datetime 0.6.11",
@@ -12244,7 +8419,7 @@
122448419source = "registry+https://github.com/rust-lang/crates.io-index"
122458420checksum = "6975367e4d2ef766d86af01ffad14b622fecc8d4357a998fbc4deb6e9bacaf9b"
122468421dependencies = [
12247 "indexmap 2.14.0",
8422 "indexmap",
122488423 "toml_datetime 1.1.1+spec-1.1.0",
122498424 "toml_parser",
122508425 "winnow 1.0.4",
@@ -12287,17 +8462,12 @@
122878462source = "registry+https://github.com/rust-lang/crates.io-index"
122888463checksum = "4cfcf7e2740e6fc6d4d688b4ef00650406bb94adf4731e43c096c3a19fe40840"
122898464dependencies = [
12290 "async-compression",
122918465 "bitflags 2.13.1",
122928466 "bytes",
12293 "futures-core",
122948467 "futures-util",
122958468 "http 1.5.0",
122968469 "http-body 1.1.0",
12297 "http-body-util",
122988470 "pin-project-lite",
12299 "tokio",
12300 "tokio-util",
123018471 "tower",
123028472 "tower-layer",
123038473 "tower-service",
@@ -12368,18 +8538,6 @@
123688538]
123698539
123708540[[package]]
12371name = "tracing-futures"
12372version = "0.2.5"
12373source = "registry+https://github.com/rust-lang/crates.io-index"
12374checksum = "97d095ae15e245a057c8e8451bab9b3ee1e1f68e9ba2b4fbc18d0ac5237835f2"
12375dependencies = [
12376 "futures",
12377 "futures-task",
12378 "pin-project",
12379 "tracing",
12380]
12381
12382[[package]]
123838541name = "tracing-log"
123848542version = "0.2.0"
123858543source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -12421,16 +8579,6 @@
124218579checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
124228580
124238581[[package]]
12424name = "tryhard"
12425version = "0.5.2"
12426source = "registry+https://github.com/rust-lang/crates.io-index"
12427checksum = "9fe58ebd5edd976e0fe0f8a14d2a04b7c81ef153ea9a54eebc42e67c2c23b4e5"
12428dependencies = [
12429 "pin-project-lite",
12430 "tokio",
12431]
12432
12433[[package]]
124348582name = "tungstenite"
124358583version = "0.29.0"
124368584source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -12442,8 +8590,6 @@
124428590 "httparse",
124438591 "log 0.4.33",
124448592 "rand 0.9.5",
12445 "rustls",
12446 "rustls-pki-types",
124478593 "sha1 0.10.7",
124488594 "thiserror 2.0.20",
124498595]
@@ -12515,12 +8661,6 @@
125158661checksum = "5c1cb5db39152898a79168971543b1cb5020dff7fe43c8dc468b0885f5e29df5"
125168662
125178663[[package]]
12518name = "unicode-blocks"
12519version = "0.1.10"
12520source = "registry+https://github.com/rust-lang/crates.io-index"
12521checksum = "328edfd6d0bb91a22e592bed3a3b54c7b1f5c92a517f5a7aca24a2caef10c363"
12522
12523[[package]]
125248664name = "unicode-bom"
125258665version = "2.0.3"
125268666source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -12542,45 +8682,18 @@
125428682]
125438683
125448684[[package]]
12545name = "unicode-normalization-alignments"
12546version = "0.1.12"
12547source = "registry+https://github.com/rust-lang/crates.io-index"
12548checksum = "43f613e4fa046e69818dd287fdc4bc78175ff20331479dab6e1b0f98d57062de"
12549dependencies = [
12550 "smallvec",
12551]
12552
12553[[package]]
125548685name = "unicode-properties"
125558686version = "0.1.4"
125568687source = "registry+https://github.com/rust-lang/crates.io-index"
125578688checksum = "7df058c713841ad818f1dc5d3fd88063241cc61f49f5fbea4b951e8cf5a8d71d"
125588689
125598690[[package]]
12560name = "unicode-segmentation"
12561version = "1.13.3"
12562source = "registry+https://github.com/rust-lang/crates.io-index"
12563checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8"
12564
12565[[package]]
12566name = "unicode-width"
12567version = "0.2.2"
12568source = "registry+https://github.com/rust-lang/crates.io-index"
12569checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
12570
12571[[package]]
125728691name = "unicode-xid"
125738692version = "0.2.6"
125748693source = "registry+https://github.com/rust-lang/crates.io-index"
125758694checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
125768695
125778696[[package]]
12578name = "unicode_categories"
12579version = "0.1.1"
12580source = "registry+https://github.com/rust-lang/crates.io-index"
12581checksum = "39ec24b3121d976906ece63c9daad25b85969647682eee313cb5779fdd69e14e"
12582
12583[[package]]
125848697name = "universal-hash"
125858698version = "0.5.1"
125868699source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -12601,12 +8714,6 @@
126018714]
126028715
126038716[[package]]
12604name = "unsafe-libyaml"
12605version = "0.2.11"
12606source = "registry+https://github.com/rust-lang/crates.io-index"
12607checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861"
12608
12609[[package]]
126108717name = "untrusted"
126118718version = "0.7.1"
126128719source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -12619,25 +8726,6 @@
126198726checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
126208727
126218728[[package]]
12622name = "ureq"
12623version = "2.12.1"
12624source = "registry+https://github.com/rust-lang/crates.io-index"
12625checksum = "02d1a66277ed75f640d608235660df48c8e3c19f3b4edb6a263315626cc3c01d"
12626dependencies = [
12627 "base64 0.22.1",
12628 "flate2",
12629 "log 0.4.33",
12630 "once_cell",
12631 "rustls",
12632 "rustls-pki-types",
12633 "serde",
12634 "serde_json",
12635 "socks",
12636 "url 2.5.8",
12637 "webpki-roots 0.26.11",
12638]
12639
12640[[package]]
126418729name = "url"
126428730version = "1.7.2"
126438731source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -12693,12 +8781,6 @@
126938781checksum = "c8232dd3cdaed5356e0f716d285e4b40b932ac434100fe9b7e0e8e935b9e6246"
126948782
126958783[[package]]
12696name = "utf8-ranges"
12697version = "1.0.5"
12698source = "registry+https://github.com/rust-lang/crates.io-index"
12699checksum = "7fcfc827f90e53a02eaef5e535ee14266c1d569214c6aa70133a624d8a3164ba"
12700
12701[[package]]
127028784name = "utf8_iter"
127038785version = "1.0.4"
127048786source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -12710,7 +8792,7 @@
127108792source = "registry+https://github.com/rust-lang/crates.io-index"
127118793checksum = "8bde15df68e80b16c7d16b9616e80770ad158988daa56a27dccd1e55558b0160"
127128794dependencies = [
12713 "indexmap 2.14.0",
8795 "indexmap",
127148796 "serde",
127158797 "serde_json",
127168798 "utoipa-gen",
@@ -12760,17 +8842,6 @@
127608842]
127618843
127628844[[package]]
12763name = "v_frame"
12764version = "0.3.9"
12765source = "registry+https://github.com/rust-lang/crates.io-index"
12766checksum = "666b7727c8875d6ab5db9533418d7c764233ac9c0cff1d469aec8fa127597be2"
12767dependencies = [
12768 "aligned-vec",
12769 "num-traits",
12770 "wasm-bindgen",
12771]
12772
12773[[package]]
127748845name = "valuable"
127758846version = "0.1.1"
127768847source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -12897,32 +8968,6 @@
128978968]
128988969
128998970[[package]]
12900name = "wasm-streams"
12901version = "0.4.2"
12902source = "registry+https://github.com/rust-lang/crates.io-index"
12903checksum = "15053d8d85c7eccdbefef60f06769760a563c7f0a9d6902a13d35c7800b0ad65"
12904dependencies = [
12905 "futures-util",
12906 "js-sys",
12907 "wasm-bindgen",
12908 "wasm-bindgen-futures",
12909 "web-sys",
12910]
12911
12912[[package]]
12913name = "wasm-streams"
12914version = "0.5.0"
12915source = "registry+https://github.com/rust-lang/crates.io-index"
12916checksum = "9d1ec4f6517c9e11ae630e200b2b65d193279042e28edd4a2cda233e46670bbb"
12917dependencies = [
12918 "futures-util",
12919 "js-sys",
12920 "wasm-bindgen",
12921 "wasm-bindgen-futures",
12922 "web-sys",
12923]
12924
12925[[package]]
129268971name = "web"
129278972version = "0.1.0"
129288973source = "git+https://gitea.gitdata.me/GitDataAi/web.git?rev=67436b2ad9#67436b2ad97b6d0ccc548cb3b1d5691711a01214"
@@ -12974,24 +9019,6 @@
129749019]
129759020
129769021[[package]]
12977name = "webpki-root-certs"
12978version = "1.0.9"
12979source = "registry+https://github.com/rust-lang/crates.io-index"
12980checksum = "b96554aa2acc8ccdb7e1c9a58a7a68dd5d13bccc69cd124cb09406db612a1c9b"
12981dependencies = [
12982 "rustls-pki-types",
12983]
12984
12985[[package]]
12986name = "webpki-roots"
12987version = "0.26.11"
12988source = "registry+https://github.com/rust-lang/crates.io-index"
12989checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9"
12990dependencies = [
12991 "webpki-roots 1.0.9",
12992]
12993
12994[[package]]
129959022name = "webpki-roots"
129969023version = "1.0.9"
129979024source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -13001,12 +9028,6 @@
130019028]
130029029
130039030[[package]]
13004name = "weezl"
13005version = "0.1.12"
13006source = "registry+https://github.com/rust-lang/crates.io-index"
13007checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88"
13008
13009[[package]]
130109031name = "whoami"
130119032version = "2.1.3"
130129033source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -13127,17 +9148,6 @@
131279148]
131289149
131299150[[package]]
13130name = "windows-registry"
13131version = "0.6.1"
13132source = "registry+https://github.com/rust-lang/crates.io-index"
13133checksum = "02752bf7fbdcce7f2a27a742f798510f3e5ad88dbe84871e5168e2120c3d5720"
13134dependencies = [
13135 "windows-link",
13136 "windows-result",
13137 "windows-strings",
13138]
13139
13140[[package]]
131419151name = "windows-result"
131429152version = "0.4.1"
131439153source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -13184,15 +9194,6 @@
131849194
131859195[[package]]
131869196name = "windows-sys"
13187version = "0.60.2"
13188source = "registry+https://github.com/rust-lang/crates.io-index"
13189checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
13190dependencies = [
13191 "windows-targets 0.53.5",
13192]
13193
13194[[package]]
13195name = "windows-sys"
131969197version = "0.61.2"
131979198source = "registry+https://github.com/rust-lang/crates.io-index"
131989199checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
@@ -13224,7 +9225,7 @@
132249225 "windows_aarch64_gnullvm 0.52.6",
132259226 "windows_aarch64_msvc 0.52.6",
132269227 "windows_i686_gnu 0.52.6",
13227 "windows_i686_gnullvm 0.52.6",
9228 "windows_i686_gnullvm",
132289229 "windows_i686_msvc 0.52.6",
132299230 "windows_x86_64_gnu 0.52.6",
132309231 "windows_x86_64_gnullvm 0.52.6",
@@ -13232,23 +9233,6 @@
132329233]
132339234
132349235[[package]]
13235name = "windows-targets"
13236version = "0.53.5"
13237source = "registry+https://github.com/rust-lang/crates.io-index"
13238checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
13239dependencies = [
13240 "windows-link",
13241 "windows_aarch64_gnullvm 0.53.1",
13242 "windows_aarch64_msvc 0.53.1",
13243 "windows_i686_gnu 0.53.1",
13244 "windows_i686_gnullvm 0.53.1",
13245 "windows_i686_msvc 0.53.1",
13246 "windows_x86_64_gnu 0.53.1",
13247 "windows_x86_64_gnullvm 0.53.1",
13248 "windows_x86_64_msvc 0.53.1",
13249]
13250
13251[[package]]
132529236name = "windows-threading"
132539237version = "0.2.1"
132549238source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -13270,12 +9254,6 @@
132709254checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
132719255
132729256[[package]]
13273name = "windows_aarch64_gnullvm"
13274version = "0.53.1"
13275source = "registry+https://github.com/rust-lang/crates.io-index"
13276checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
13277
13278[[package]]
132799257name = "windows_aarch64_msvc"
132809258version = "0.48.5"
132819259source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -13288,12 +9266,6 @@
132889266checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
132899267
132909268[[package]]
13291name = "windows_aarch64_msvc"
13292version = "0.53.1"
13293source = "registry+https://github.com/rust-lang/crates.io-index"
13294checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
13295
13296[[package]]
132979269name = "windows_i686_gnu"
132989270version = "0.48.5"
132999271source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -13306,24 +9278,12 @@
133069278checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
133079279
133089280[[package]]
13309name = "windows_i686_gnu"
13310version = "0.53.1"
13311source = "registry+https://github.com/rust-lang/crates.io-index"
13312checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
13313
13314[[package]]
133159281name = "windows_i686_gnullvm"
133169282version = "0.52.6"
133179283source = "registry+https://github.com/rust-lang/crates.io-index"
133189284checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
133199285
133209286[[package]]
13321name = "windows_i686_gnullvm"
13322version = "0.53.1"
13323source = "registry+https://github.com/rust-lang/crates.io-index"
13324checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
13325
13326[[package]]
133279287name = "windows_i686_msvc"
133289288version = "0.48.5"
133299289source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -13336,12 +9296,6 @@
133369296checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
133379297
133389298[[package]]
13339name = "windows_i686_msvc"
13340version = "0.53.1"
13341source = "registry+https://github.com/rust-lang/crates.io-index"
13342checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
13343
13344[[package]]
133459299name = "windows_x86_64_gnu"
133469300version = "0.48.5"
133479301source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -13354,12 +9308,6 @@
133549308checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
133559309
133569310[[package]]
13357name = "windows_x86_64_gnu"
13358version = "0.53.1"
13359source = "registry+https://github.com/rust-lang/crates.io-index"
13360checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
13361
13362[[package]]
133639311name = "windows_x86_64_gnullvm"
133649312version = "0.48.5"
133659313source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -13372,12 +9320,6 @@
133729320checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
133739321
133749322[[package]]
13375name = "windows_x86_64_gnullvm"
13376version = "0.53.1"
13377source = "registry+https://github.com/rust-lang/crates.io-index"
13378checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
13379
13380[[package]]
133819323name = "windows_x86_64_msvc"
133829324version = "0.48.5"
133839325source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -13390,12 +9332,6 @@
133909332checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
133919333
133929334[[package]]
13393name = "windows_x86_64_msvc"
13394version = "0.53.1"
13395source = "registry+https://github.com/rust-lang/crates.io-index"
13396checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
13397
13398[[package]]
133999335name = "winnow"
134009336version = "0.7.15"
134019337source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -13467,12 +9403,6 @@
134679403checksum = "aee1b19627c7c60102ab80d3a9cbe18de90bfe03bfa6c3715447681f0e8c8af6"
134689404
134699405[[package]]
13470name = "y4m"
13471version = "0.8.0"
13472source = "registry+https://github.com/rust-lang/crates.io-index"
13473checksum = "7a5a4b21e1a62b67a2970e6831bc091d7b87e119e7f9791aef9702e3bef04448"
13474
13475[[package]]
134769406name = "yansi"
134779407version = "1.0.1"
134789408source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -13592,7 +9522,7 @@
135929522 "arbitrary",
135939523 "crc32fast",
135949524 "flate2",
13595 "indexmap 2.14.0",
9525 "indexmap",
135969526 "memchr",
135979527 "zopfli",
135989528]
@@ -13647,28 +9577,4 @@
136479577dependencies = [
136489578 "cc",
136499579 "pkg-config",
13650]
13651
13652[[package]]
13653name = "zune-core"
13654version = "0.5.3"
13655source = "registry+https://github.com/rust-lang/crates.io-index"
13656checksum = "d56377fd46368984a170bc5aac5567e52ca5da874caa60bea39fcbca78fb658b"
13657
13658[[package]]
13659name = "zune-inflate"
13660version = "0.2.54"
13661source = "registry+https://github.com/rust-lang/crates.io-index"
13662checksum = "73ab332fe2f6680068f3582b16a24f90ad7096d5d39b974d1c0aff0125116f02"
13663dependencies = [
13664 "simd-adler32",
13665]
13666
13667[[package]]
13668name = "zune-jpeg"
13669version = "0.5.15"
13670source = "registry+https://github.com/rust-lang/crates.io-index"
13671checksum = "27bc9d5b815bc103f142aa054f561d9187d191692ec7c2d1e2b4737f8dbd7296"
13672dependencies = [
13673 "zune-core",
136749580]
Modified Cargo.toml Cargo.toml +0 −4 View Cargo.toml
@@ -29,7 +29,6 @@
2929git = { path = "lib/git" }
3030webapi = { path = "lib/webapi" }
3131pulls = { path = "lib/pulls" }
32agent = { path = "lib/agent" }
3332
3433
3534
@@ -49,7 +48,6 @@
4948dotenvy = "0.15"
5049rust-s3-async = "0.35.0"
5150redis = { version = "1.6.0", features = ["aio", "tokio-comp", "connection-manager", "cluster-async"] }
52async-nats = "0.50"
5351sea-orm = { version = "2.0.2", features = ["sqlx-postgres", "runtime-tokio-rustls"] }
5452oxcache = { version = "0.4.3", features = ["core"] }
5553async-trait = "0.1.92"
@@ -78,8 +76,6 @@
7876thiserror = "2.0.20"
7977gix = "0.86.0"
8078gitbaby = { git="https://gitea.gitdata.me/GitDataAi/GitBaby.git", rev = "69bd99a" }
81cubesandbox = { git = "https://gitea.gitdata.me/GitDataAi/sanbox-client.git", rev = "91ba6f56ac" }
82rig = "0.42"
8379wasm-bindgen = "0.2"
8480chrono = "0.4.45"
8581maud = { version = "0.27", features = ["axum"] }
Modified Dockerfile Dockerfile +2 −2 View Dockerfile
@@ -27,7 +27,7 @@
2727 --mount=type=cache,target=/build/target \
2828 cargo build --release --workspace --bins && \
2929 mkdir -p /out && \
30 for b in apihost githost synchost mails migrate openapi ai; do \
30 for b in apihost githost synchost mails migrate openapi; do \
3131 cp "target/release/$b" /out/; \
3232 done
3333
@@ -48,7 +48,7 @@
4848WORKDIR /app
4949
5050COPY --chown=gitdata:gitdata config/default.toml config/default.toml
51COPY --from=builder /out/apihost /out/githost /out/synchost /out/mails /out/migrate /out/openapi /out/ai /usr/local/bin/
51COPY --from=builder /out/apihost /out/githost /out/synchost /out/mails /out/migrate /out/openapi /usr/local/bin/
5252
5353USER gitdata
5454