feat(agent): implement agent module with configuration, runtime, and sandbox management

Modified config/default.toml +23 −1 View config/default.toml

@@ -247,4 +247,26 @@

247247[githost]

248248enabled = true

249249http_bind_addr = "0.0.0.0"

250http_port = 9418

No newline at end of file

250http_port = 9418

251

252[agent]

253

254[agent.provider]

255base_url = ""

256api_key = ""

257model = ""

258

259[agent.sandbox]

260api_url = ""

261api_key = ""

262template_id = ""

263timeout_secs = 3600

264lease_secs = 600

265

266[agent.runtime]

267default_max_turns = 32

268event_stream_maxlen = 10000

269event_ttl_secs = 86400

270tool_output_max_bytes = 32768

271artifact_max_size = 104857600

272artifact_dir = ""

Added lib/agent/src/runtime/config.rs +126 −0 View lib/agent/src/runtime/config.rs

@@ -0,0 +1,126 @@

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}

32

33#[derive(Clone, Debug)]

34pub struct RuntimeConfig {

35 pub provider: ProviderSettings,

36 pub sandbox: SandboxSettings,

37 pub limits: Limits,

38}

39

40impl From<&AgentConfig> for RuntimeConfig {

41 fn from(cfg: &AgentConfig) -> Self {

42 Self {

43 provider: ProviderSettings {

44 base_url: cfg.provider.base_url.clone(),

45 api_key: cfg.provider.api_key.clone(),

46 model: cfg.provider.model.clone(),

47 },

48 sandbox: SandboxSettings {

49 api_url: cfg.sandbox.api_url.clone(),

50 api_key: cfg.sandbox.api_key.clone(),

51 template_id: cfg.sandbox.template_id.clone(),

52 timeout: Duration::from_secs(cfg.sandbox.timeout_secs),

53 lease: Duration::from_secs(cfg.sandbox.lease_secs),

54 },

55 limits: Limits {

56 default_max_turns: cfg.runtime.default_max_turns,

57 event_stream_maxlen: cfg.runtime.event_stream_maxlen,

58 event_ttl_secs: cfg.runtime.event_ttl_secs,

59 tool_output_max_bytes: cfg.runtime.tool_output_max_bytes,

60 artifact_max_size: cfg.runtime.artifact_max_size,

61 artifact_dir: cfg.runtime.artifact_dir.clone(),

62 },

63 }

64 }

65}

66

67impl RuntimeConfig {

68 pub fn validate(&self) -> Result<()> {

69 if self.provider.base_url.is_empty() {

70 return Err(AgentError::Config(

71 "agent provider base_url must be set".to_string(),

72 ));

73 }

74 if self.provider.model.is_empty() {

75 return Err(AgentError::Config(

76 "agent provider model must be set".to_string(),

77 ));

78 }

79 if self.sandbox.api_url.is_empty() {

80 return Err(AgentError::Config(

81 "agent sandbox api_url must be set".to_string(),

82 ));

83 }

84 if self.sandbox.api_key.is_empty() {

85 return Err(AgentError::Config(

86 "agent sandbox api_key must be set".to_string(),

87 ));

88 }

89 if self.sandbox.template_id.is_empty() {

90 return Err(AgentError::Config(

91 "agent sandbox template_id must be set".to_string(),

92 ));

93 }

94 if self.sandbox.lease.is_zero() || self.sandbox.timeout.is_zero() {

95 return Err(AgentError::Config(

96 "agent sandbox timeouts must be positive".to_string(),

97 ));

98 }

99 if self.sandbox.lease > self.sandbox.timeout {

100 return Err(AgentError::Config(

101 "agent sandbox lease must not exceed timeout".to_string(),

102 ));

103 }

104 if self.limits.default_max_turns == 0 {

105 return Err(AgentError::Config(

106 "agent default_max_turns must be positive".to_string(),

107 ));

108 }

109 if self.limits.event_stream_maxlen == 0 {

110 return Err(AgentError::Config(

111 "agent event_stream_maxlen must be positive".to_string(),

112 ));

113 }

114 if self.limits.tool_output_max_bytes == 0 {

115 return Err(AgentError::Config(

116 "agent tool_output_max_bytes must be positive".to_string(),

117 ));

118 }

119 if self.limits.artifact_max_size <= 0 {

120 return Err(AgentError::Config(

121 "agent artifact_max_size must be positive".to_string(),

122 ));

123 }

124 Ok(())

125 }

126}

Added lib/agent/src/runtime/engine.rs +567 −0 View lib/agent/src/runtime/engine.rs

@@ -0,0 +1,567 @@

1use std::sync::Arc;

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, 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::config::RuntimeConfig;

25use super::events::{RunEvent, StopReason};

26use super::persist::{self, RunContext, RunTerminal};

27use super::provider;

28use super::sandbox::SandboxManager;

29use super::sink::{EventEmitter, EventSink};

30use crate::error::{AgentError, Result};

31use crate::tools::artifact::save_artifact;

32use crate::tools::{ToolEnv, build_tools, truncate_output};

33

34const DEFAULT_PREAMBLE: &str = "You are GitData Agent, an autonomous engineering assistant working inside an isolated sandbox.

35Use 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.

36Work step by step, verify results with the tools, and finish with a concise summary of what you did and which artifacts you saved.";

37

38const MAX_SWEEP_FILES: usize = 256;

39const MAX_SWEEP_DEPTH: usize = 8;

40

41#[derive(Clone)]

42pub struct AgentRuntime {

43 state: AppState,

44 config: RuntimeConfig,

45 client: CompletionsClient,

46}

47

48#[derive(Clone, Debug, Serialize, Deserialize)]

49pub struct RunOutcome {

50 pub run_id: Uuid,

51 pub state: AgentRunState,

52 pub stop_reason: StopReason,

53 pub final_text: Option<String>,

54 pub usage: serde_json::Value,

55 pub history: Vec<Message>,

56 pub sandbox_id: Option<String>,

57 pub artifacts: Vec<Uuid>,

58}

59

60pub struct RunHandle {

61 pub run_id: Uuid,

62 pub events: mpsc::UnboundedReceiver<RunEvent>,

63 pub outcome: JoinHandle<Result<RunOutcome>>,

64}

65

66struct Terminal {

67 state: AgentRunState,

68 stop_reason: StopReason,

69 final_text: Option<String>,

70 error: Option<String>,

71 history: Vec<Message>,

72 usage: Usage,

73}

74

75impl AgentRuntime {

76 pub fn new(state: AppState) -> Result<Self> {

77 let config = RuntimeConfig::from(&state.config.agent);

78 config.validate()?;

79 let client = provider::build_client(&config.provider)?;

80 Ok(Self {

81 state,

82 config,

83 client,

84 })

85 }

86

87 pub fn config(&self) -> &RuntimeConfig {

88 &self.config

89 }

90

91 pub async fn submit(&self, conversation_id: Uuid, prompt: String) -> Result<RunHandle> {

92 let conv = conversation::Entity::find_by_id(conversation_id)

93 .one(self.state.database.read())

94 .await?

95 .ok_or_else(|| {

96 AgentError::NotFound(format!("agent conversation {conversation_id}"))

97 })?;

98 if conv.closed_at.is_some() {

99 return Err(AgentError::Conflict(

100 "conversation is closed".to_string(),

101 ));

102 }

103 let now = OffsetDateTime::now_utc();

104 let run_id = Uuid::now_v7();

105 run::ActiveModel {

106 id: Set(run_id),

107 conversation_id: Set(conversation_id),

108 state: Set(AgentRunState::Queued),

109 prompt: Set(prompt),

110 final_text: Set(None),

111 usage: Set(serde_json::json!({})),

112 error: Set(None),

113 sandbox_id: Set(None),

114 started_at: Set(None),

115 finished_at: Set(None),

116 created_at: Set(now),

117 updated_at: Set(now),

118 }

119 .insert(self.state.database.write())

120 .await?;

121 let (tx, rx) = mpsc::unbounded_channel();

122 let rt = self.clone();

123 let outcome = tokio::spawn(async move { rt.drive(run_id, tx, true).await });

124 Ok(RunHandle {

125 run_id,

126 events: rx,

127 outcome,

128 })

129 }

130

131 pub async fn execute(&self, run_id: Uuid) -> Result<RunOutcome> {

132 let (tx, rx) = mpsc::unbounded_channel();

133 drop(rx);

134 self.clone().drive(run_id, tx, false).await

135 }

136

137 pub async fn request_cancel(&self, run_id: Uuid) -> Result<bool> {

138 persist::request_cancel(&self.state.database, run_id).await

139 }

140

141 async fn drive(

142 self,

143 run_id: Uuid,

144 events_tx: mpsc::UnboundedSender<RunEvent>,

145 consumer_cancel: bool,

146 ) -> Result<RunOutcome> {

147 let db = self.state.database.clone();

148 let sink = EventSink::new(

149 self.state.redis.clone(),

150 self.config.limits.event_stream_maxlen,

151 self.config.limits.event_ttl_secs,

152 );

153 let emitter = EventEmitter::new(sink, run_id, events_tx);

154

155 let ctx = match persist::load_run_context(&db, run_id).await {

156 Ok(ctx) => ctx,

157 Err(e) => {

158 emitter

159 .emit(RunEvent::RunError {

160 message: e.to_string(),

161 })

162 .await;

163 return Err(e);

164 }

165 };

166 match persist::mark_running(&db, run_id).await {

167 Ok(true) => {}

168 Ok(false) => {

169 let e = AgentError::Conflict(format!("run {run_id} is not queued"));

170 emitter

171 .emit(RunEvent::RunError {

172 message: e.to_string(),

173 })

174 .await;

175 return Err(e);

176 }

177 Err(e) => {

178 emitter

179 .emit(RunEvent::RunError {

180 message: e.to_string(),

181 })

182 .await;

183 return Err(e);

184 }

185 }

186 emitter

187 .emit(RunEvent::RunStarted {

188 run_id,

189 conversation_id: ctx.conversation.id,

190 agent_id: ctx.agent.id,

191 })

192 .await;

193

194 let manager = match SandboxManager::new(&self.config.sandbox) {

195 Ok(m) => m,

196 Err(e) => {

197 terminate_failed(&db, &emitter, &ctx, e.to_string()).await;

198 return Err(e);

199 }

200 };

201 let mut lease = match manager

202 .acquire(&db, run_id, ctx.run.sandbox_id.as_deref())

203 .await

204 {

205 Ok(lease) => lease,

206 Err(e) => {

207 terminate_failed(&db, &emitter, &ctx, format!("sandbox acquire failed: {e}")).await;

208 return Err(e);

209 }

210 };

211 manager.start_heartbeat(db.clone(), &mut lease);

212 let sandbox_id = lease.sandbox.sandbox_id.clone();

213 if let Err(e) = persist::save_sandbox_id(&db, run_id, &sandbox_id).await {

214 manager.release(&db, lease).await;

215 terminate_failed(&db, &emitter, &ctx, e.to_string()).await;

216 return Err(e);

217 }

218

219 let tool_env = Arc::new(ToolEnv {

220 sandbox: lease.sandbox.clone(),

221 state: self.state.clone(),

222 run_id,

223 emitter: emitter.clone(),

224 });

225 let agent = self

226 .client

227 .agent(self.config.provider.model.clone())

228 .preamble(

229 ctx.agent

230 .preamble

231 .as_deref()

232 .map(str::trim)

233 .filter(|p| !p.is_empty())

234 .unwrap_or(DEFAULT_PREAMBLE),

235 )

236 .dynamic_tools(build_tools(tool_env.clone()))

237 .default_max_turns(self.config.limits.default_max_turns)

238 .add_hook(CancelHook {

239 db: db.clone(),

240 run_id,

241 })

242 .build();

243

244 let mut stream = agent

245 .stream_chat(

246 Message::user(ctx.run.prompt.clone()),

247 ctx.history.clone(),

248 )

249 .max_turns(self.config.limits.default_max_turns)

250 .await;

251

252 let mut final_response: Option<PromptResponse> = None;

253 let mut stream_error: Option<StreamingError> = None;

254 let mut usage_sum = Usage::new();

255 let mut consumer_gone = false;

256 while let Some(item) = stream.next().await {

257 match item {

258 Ok(MultiTurnStreamItem::StreamAssistantItem(content)) => match content {

259 StreamedAssistantContent::Text(t) => {

260 emitter

261 .emit(RunEvent::TextDelta { text: t.text })

262 .await;

263 }

264 StreamedAssistantContent::ReasoningDelta { reasoning, .. } => {

265 emitter

266 .emit(RunEvent::ReasoningDelta { text: reasoning })

267 .await;

268 }

269 StreamedAssistantContent::ToolCall { tool_call, .. } => {

270 emitter

271 .emit(RunEvent::ToolCall {

272 id: tool_call.id.as_str().to_string(),

273 name: tool_call.function.name.clone(),

274 args: tool_call.function.arguments.clone(),

275 })

276 .await;

277 }

278 _ => {}

279 },

280 Ok(MultiTurnStreamItem::StreamUserItem(StreamedUserContent::ToolResult {

281 tool_result,

282 ..

283 })) => {

284 let mut output = String::new();

285 for part in &tool_result.content {

286 match part {

287 ToolResultContent::Text(t) => output.push_str(&t.text),

288 ToolResultContent::Json { value } => {

289 output.push_str(&value.to_string());

290 }

291 _ => {}

292 }

293 }

294 let (mut output, truncated) =

295 truncate_output(&output, self.config.limits.tool_output_max_bytes);

296 if truncated {

297 output.push_str("\n[truncated]");

298 }

299 emitter

300 .emit(RunEvent::ToolResult {

301 id: tool_result.call.as_str().to_string(),

302 name: tool_result.name.clone(),

303 output,

304 })

305 .await;

306 }

307 Ok(MultiTurnStreamItem::CompletionCall(call)) => {

308 usage_sum += call.usage;

309 emitter

310 .emit(RunEvent::Usage {

311 input_tokens: call.usage.input_tokens,

312 output_tokens: call.usage.output_tokens,

313 total_tokens: call.usage.total_tokens,

314 })

315 .await;

316 }

317 Ok(MultiTurnStreamItem::FinalResponse(resp)) => final_response = Some(resp),

318 Ok(_) => {}

319 Err(e) => {

320 stream_error = Some(e);

321 break;

322 }

323 }

324 if consumer_cancel && emitter.consumer_closed() {

325 consumer_gone = true;

326 break;

327 }

328 }

329 drop(stream);

330

331 let terminal = if consumer_gone {

332 Terminal {

333 state: AgentRunState::Cancelled,

334 stop_reason: StopReason::Cancelled,

335 final_text: None,

336 error: Some("consumer disconnected".to_string()),

337 history: ctx.history.clone(),

338 usage: usage_sum,

339 }

340 } else if let Some(e) = stream_error {

341 match e {

342 StreamingError::Prompt(pe) => match *pe {

343 PromptError::MaxTurnsError {

344 max_turns,

345 chat_history,

346 ..

347 } => Terminal {

348 state: AgentRunState::Failure,

349 stop_reason: StopReason::MaxTurns,

350 final_text: None,

351 error: Some(format!("max turns exceeded ({max_turns})")),

352 history: *chat_history,

353 usage: usage_sum,

354 },

355 PromptError::PromptCancelled {

356 chat_history,

357 reason,

358 } => Terminal {

359 state: AgentRunState::Cancelled,

360 stop_reason: StopReason::Cancelled,

361 final_text: None,

362 error: Some(reason),

363 history: chat_history,

364 usage: usage_sum,

365 },

366 other => Terminal {

367 state: AgentRunState::Failure,

368 stop_reason: StopReason::Error,

369 final_text: None,

370 error: Some(other.to_string()),

371 history: ctx.history.clone(),

372 usage: usage_sum,

373 },

374 },

375 StreamingError::Completion(ce) => Terminal {

376 state: AgentRunState::Failure,

377 stop_reason: StopReason::Error,

378 final_text: None,

379 error: Some(ce.to_string()),

380 history: ctx.history.clone(),

381 usage: usage_sum,

382 },

383 }

384 } else if let Some(resp) = final_response {

385 Terminal {

386 state: AgentRunState::Success,

387 stop_reason: StopReason::Completed,

388 final_text: Some(resp.output.clone()),

389 error: None,

390 history: ctx

391 .history

392 .iter()

393 .cloned()

394 .chain(resp.messages.clone().unwrap_or_default())

395 .collect(),

396 usage: resp.usage,

397 }

398 } else {

399 Terminal {

400 state: AgentRunState::Failure,

401 stop_reason: StopReason::Error,

402 final_text: None,

403 error: Some("stream ended without a final response".to_string()),

404 history: ctx.history.clone(),

405 usage: usage_sum,

406 }

407 };

408

409 if !self.config.limits.artifact_dir.is_empty() {

410 sweep_artifacts(&tool_env).await;

411 }

412

413 let usage_json =

414 serde_json::to_value(terminal.usage).unwrap_or_else(|_| serde_json::json!({}));

415 if let Err(e) = persist::finish_run(

416 &db,

417 run_id,

418 ctx.conversation.id,

419 RunTerminal {

420 state: terminal.state,

421 final_text: terminal.final_text.clone(),

422 usage: usage_json.clone(),

423 error: terminal.error.clone(),

424 history: terminal.history.clone(),

425 },

426 )

427 .await

428 {

429 manager.release(&db, lease).await;

430 emitter

431 .emit(RunEvent::RunError {

432 message: e.to_string(),

433 })

434 .await;

435 return Err(e);

436 }

437 manager.release(&db, lease).await;

438

439 match terminal.stop_reason {

440 StopReason::Error => {

441 emitter

442 .emit(RunEvent::RunError {

443 message: terminal.error.clone().unwrap_or_default(),

444 })

445 .await;

446 }

447 reason => {

448 emitter

449 .emit(RunEvent::RunFinished {

450 stop_reason: reason,

451 final_text: terminal.final_text.clone(),

452 })

453 .await;

454 }

455 }

456

457 let artifacts = persist::artifact_ids(&db, run_id).await.unwrap_or_default();

458 Ok(RunOutcome {

459 run_id,

460 state: terminal.state,

461 stop_reason: terminal.stop_reason,

462 final_text: terminal.final_text,

463 usage: usage_json,

464 history: terminal.history,

465 sandbox_id: Some(sandbox_id),

466 artifacts,

467 })

468 }

469}

470

471struct CancelHook {

472 db: Arc<AppDatabase>,

473 run_id: Uuid,

474}

475

476impl AgentHook for CancelHook {

477 async fn on_completion_call(

478 &self,

479 _ctx: &HookContext,

480 _event: CompletionCallEvent<'_>,

481 ) -> CompletionCallAction {

482 match persist::cancel_requested(&self.db, self.run_id).await {

483 Ok(true) => CompletionCallAction::stop("cancel requested"),

484 Ok(false) => CompletionCallAction::continue_run(),

485 Err(e) => {

486 tracing::warn!(error = %e, "agent run cancel check failed");

487 CompletionCallAction::continue_run()

488 }

489 }

490 }

491}

492

493async fn terminate_failed(

494 db: &Arc<AppDatabase>,

495 emitter: &EventEmitter,

496 ctx: &RunContext,

497 message: String,

498) {

499 let terminal = RunTerminal {

500 state: AgentRunState::Failure,

501 final_text: None,

502 usage: serde_json::json!({}),

503 error: Some(message.clone()),

504 history: ctx.history.clone(),

505 };

506 if let Err(e) = persist::finish_run(db, ctx.run.id, ctx.conversation.id, terminal).await {

507 tracing::error!(run_id = %ctx.run.id, error = %e, "failed to persist agent run failure");

508 }

509 emitter.emit(RunEvent::RunError { message }).await;

510}

511

512async fn sweep_artifacts(env: &Arc<ToolEnv>) {

513 let dir = env.limits().artifact_dir.clone();

514 if dir.is_empty() {

515 return;

516 }

517 let existing = match persist::artifact_paths(env.db(), env.run_id).await {

518 Ok(paths) => paths,

519 Err(e) => {

520 tracing::warn!(error = %e, "failed to load existing artifact paths");

521 return;

522 }

523 };

524 let files = env.sandbox.files();

525 let mut stack: Vec<(String, usize)> = vec![(dir, 0)];

526 let mut budget = MAX_SWEEP_FILES;

527 while let Some((path, depth)) = stack.pop() {

528 if depth > MAX_SWEEP_DEPTH {

529 continue;

530 }

531 let entries = match files.list(&path).await {

532 Ok(entries) => entries,

533 Err(e) => {

534 tracing::warn!(path = %path, error = %e, "artifact sweep list failed");

535 continue;

536 }

537 };

538 for entry in entries {

539 if entry.is_dir() {

540 stack.push((entry.path, depth + 1));

541 continue;

542 }

543 if budget == 0 {

544 return;

545 }

546 if existing.contains(&entry.path) {

547 continue;

548 }

549 match save_artifact(env, &entry.path, None, AgentArtifactSource::Sweep).await {

550 Ok(row) => {

551 env.emitter

552 .emit(RunEvent::ArtifactSaved {

553 artifact_id: row.id,

554 name: row.name.clone(),

555 sandbox_path: row.sandbox_path.clone(),

556 size: row.size,

557 })

558 .await;

559 budget -= 1;

560 }

561 Err(message) => {

562 tracing::warn!(path = %entry.path, error = %message, "artifact sweep save failed");

563 }

564 }

565 }

566 }

567}

Added lib/agent/src/runtime/events.rs +55 −0 View lib/agent/src/runtime/events.rs

@@ -0,0 +1,55 @@

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, Debug, Serialize, Deserialize)]

14#[serde(tag = "type", rename_all = "snake_case")]

15pub enum RunEvent {

16 RunStarted {

17 run_id: Uuid,

18 conversation_id: Uuid,

19 agent_id: Uuid,

20 },

21 TextDelta {

22 text: String,

23 },

24 ReasoningDelta {

25 text: String,

26 },

27 ToolCall {

28 id: String,

29 name: String,

30 args: serde_json::Value,

31 },

32 ToolResult {

33 id: String,

34 name: String,

35 output: String,

36 },

37 ArtifactSaved {

38 artifact_id: Uuid,

39 name: String,

40 sandbox_path: String,

41 size: i64,

42 },

43 Usage {

44 input_tokens: u64,

45 output_tokens: u64,

46 total_tokens: u64,

47 },

48 RunFinished {

49 stop_reason: StopReason,

50 final_text: Option<String>,

51 },

52 RunError {

53 message: String,

54 },

55}

Added lib/agent/src/runtime/mod.rs +14 −0 View lib/agent/src/runtime/mod.rs

@@ -0,0 +1,14 @@

1pub mod config;

2pub mod engine;

3pub mod events;

4pub mod persist;

5pub mod provider;

6pub mod reaper;

7pub mod sandbox;

8pub mod sink;

9

10pub use config::RuntimeConfig;

11pub use engine::{AgentRuntime, RunHandle, RunOutcome};

12pub use events::{RunEvent, StopReason};

13pub use reaper::{SweepReport, sweep};

14pub use sink::{EventEmitter, EventSink, StreamEntry};

Added lib/agent/src/runtime/persist.rs +242 −0 View lib/agent/src/runtime/persist.rs

@@ -0,0 +1,242 @@

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(|| AgentError::NotFound(format!("agent conversation {}", run.conversation_id)))?;

30 let agent = agent::Entity::find_by_id(conversation.agent_id)

31 .one(db.read())

32 .await?

33 .ok_or_else(|| AgentError::NotFound(format!("agent {}", conversation.agent_id)))?;

34 let history: Vec<Message> = serde_json::from_value(conversation.history.clone())

35 .map_err(|e| AgentError::Internal(format!("corrupt conversation history: {e}")))?;

36 Ok(RunContext {

37 run,

38 conversation,

39 agent,

40 history,

41 })

42}

43

44pub async fn mark_running(db: &AppDatabase, run_id: Uuid) -> Result<bool> {

45 let now = OffsetDateTime::now_utc();

46 let res = run::Entity::update_many()

47 .col_expr(run::Column::State, Expr::value(AgentRunState::Running))

48 .col_expr(run::Column::StartedAt, Expr::value(Some(now)))

49 .col_expr(run::Column::UpdatedAt, Expr::value(now))

50 .filter(run::Column::Id.eq(run_id))

51 .filter(run::Column::State.eq(AgentRunState::Queued))

52 .exec(db.write())

53 .await?;

54 Ok(res.rows_affected == 1)

55}

56

57pub async fn request_cancel(db: &AppDatabase, run_id: Uuid) -> Result<bool> {

58 let now = OffsetDateTime::now_utc();

59 let res = run::Entity::update_many()

60 .col_expr(

61 run::Column::State,

62 Expr::value(AgentRunState::CancelRequested),

63 )

64 .col_expr(run::Column::UpdatedAt, Expr::value(now))

65 .filter(run::Column::Id.eq(run_id))

66 .filter(run::Column::State.eq(AgentRunState::Running))

67 .exec(db.write())

68 .await?;

69 Ok(res.rows_affected == 1)

70}

71

72pub async fn cancel_requested(db: &AppDatabase, run_id: Uuid) -> Result<bool> {

73 let row = run::Entity::find_by_id(run_id).one(db.write()).await?;

74 Ok(matches!(

75 row.map(|r| r.state),

76 Some(AgentRunState::CancelRequested)

77 ))

78}

79

80pub async fn save_sandbox_id(db: &AppDatabase, run_id: Uuid, sandbox_id: &str) -> Result<()> {

81 run::Entity::update_many()

82 .col_expr(

83 run::Column::SandboxId,

84 Expr::value(sandbox_id.to_string()),

85 )

86 .col_expr(run::Column::UpdatedAt, Expr::value(OffsetDateTime::now_utc()))

87 .filter(run::Column::Id.eq(run_id))

88 .exec(db.write())

89 .await?;

90 Ok(())

91}

92

93pub struct RunTerminal {

94 pub state: AgentRunState,

95 pub final_text: Option<String>,

96 pub usage: serde_json::Value,

97 pub error: Option<String>,

98 pub history: Vec<Message>,

99}

100

101pub async fn finish_run(

102 db: &AppDatabase,

103 run_id: Uuid,

104 conversation_id: Uuid,

105 terminal: RunTerminal,

106) -> Result<()> {

107 let now = OffsetDateTime::now_utc();

108 run::Entity::update_many()

109 .col_expr(run::Column::State, Expr::value(terminal.state))

110 .col_expr(run::Column::FinalText, Expr::value(terminal.final_text))

111 .col_expr(run::Column::Usage, Expr::value(terminal.usage))

112 .col_expr(run::Column::Error, Expr::value(terminal.error))

113 .col_expr(run::Column::FinishedAt, Expr::value(Some(now)))

114 .col_expr(run::Column::UpdatedAt, Expr::value(now))

115 .filter(run::Column::Id.eq(run_id))

116 .exec(db.write())

117 .await?;

118 let history = serde_json::to_value(&terminal.history)

119 .map_err(|e| AgentError::Internal(format!("serialize conversation history: {e}")))?;

120 conversation::Entity::update_many()

121 .col_expr(conversation::Column::History, Expr::value(history))

122 .col_expr(

123 conversation::Column::LastRunAt,

124 Expr::value(Some(now)),

125 )

126 .col_expr(

127 conversation::Column::UpdatedAt,

128 Expr::value(Some(now)),

129 )

130 .filter(conversation::Column::Id.eq(conversation_id))

131 .exec(db.write())

132 .await?;

133 Ok(())

134}

135

136pub async fn insert_sandbox(

137 db: &AppDatabase,

138 run_id: Uuid,

139 sandbox_id: &str,

140 template_id: &str,

141 lease_expires_at: OffsetDateTime,

142) -> Result<Uuid> {

143 let now = OffsetDateTime::now_utc();

144 let id = Uuid::now_v7();

145 sandbox::ActiveModel {

146 id: Set(id),

147 run_id: Set(run_id),

148 sandbox_id: Set(sandbox_id.to_string()),

149 template_id: Set(template_id.to_string()),

150 state: Set(AgentSandboxState::Active),

151 lease_expires_at: Set(lease_expires_at),

152 last_heartbeat_at: Set(Some(now)),

153 created_at: Set(now),

154 killed_at: Set(None),

155 }

156 .insert(db.write())

157 .await?;

158 Ok(id)

159}

160

161pub async fn heartbeat(

162 db: &AppDatabase,

163 row_id: Uuid,

164 lease_expires_at: OffsetDateTime,

165) -> Result<()> {

166 sandbox::Entity::update_many()

167 .col_expr(

168 sandbox::Column::LastHeartbeatAt,

169 Expr::value(Some(OffsetDateTime::now_utc())),

170 )

171 .col_expr(

172 sandbox::Column::LeaseExpiresAt,

173 Expr::value(lease_expires_at),

174 )

175 .filter(sandbox::Column::Id.eq(row_id))

176 .filter(sandbox::Column::State.eq(AgentSandboxState::Active))

177 .exec(db.write())

178 .await?;

179 Ok(())

180}

181

182pub async fn set_sandbox_state(

183 db: &AppDatabase,

184 row_id: Uuid,

185 state: AgentSandboxState,

186 killed_at: Option<OffsetDateTime>,

187) -> Result<()> {

188 let mut stmt = sandbox::Entity::update_many()

189 .col_expr(sandbox::Column::State, Expr::value(state))

190 .filter(sandbox::Column::Id.eq(row_id));

191 if let Some(at) = killed_at {

192 stmt = stmt.col_expr(sandbox::Column::KilledAt, Expr::value(Some(at)));

193 }

194 stmt.exec(db.write()).await?;

195 Ok(())

196}

197

198#[allow(clippy::too_many_arguments)]

199pub async fn insert_artifact(

200 db: &AppDatabase,

201 run_id: Uuid,

202 name: &str,

203 sandbox_path: &str,

204 bucket: &str,

205 s3_key: &str,

206 size: i64,

207 content_type: &str,

208 source: AgentArtifactSource,

209) -> Result<artifact::Model> {

210 let row = artifact::ActiveModel {

211 id: Set(Uuid::now_v7()),

212 run_id: Set(run_id),

213 name: Set(name.to_string()),

214 sandbox_path: Set(sandbox_path.to_string()),

215 bucket: Set(bucket.to_string()),

216 s3_key: Set(s3_key.to_string()),

217 size: Set(size),

218 content_type: Set(content_type.to_string()),

219 source: Set(source),

220 created_at: Set(OffsetDateTime::now_utc()),

221 }

222 .insert(db.write())

223 .await?;

224 Ok(row)

225}

226

227pub async fn artifact_ids(db: &AppDatabase, run_id: Uuid) -> Result<Vec<Uuid>> {

228 let rows = artifact::Entity::find()

229 .filter(artifact::Column::RunId.eq(run_id))

230 .order_by_asc(artifact::Column::CreatedAt)

231 .all(db.read())

232 .await?;

233 Ok(rows.into_iter().map(|r| r.id).collect())

234}

235

236pub async fn artifact_paths(db: &AppDatabase, run_id: Uuid) -> Result<Vec<String>> {

237 let rows = artifact::Entity::find()

238 .filter(artifact::Column::RunId.eq(run_id))

239 .all(db.read())

240 .await?;

241 Ok(rows.into_iter().map(|r| r.sandbox_path).collect())

242}

Added lib/agent/src/runtime/provider.rs +12 −0 View lib/agent/src/runtime/provider.rs

@@ -0,0 +1,12 @@

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}

Added lib/agent/src/runtime/reaper.rs +177 −0 View lib/agent/src/runtime/reaper.rs

@@ -0,0 +1,177 @@

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 = r

116 .started_at

117 .is_some_and(|started| started < cutoff)

118 || r.started_at.is_none();

119 if !stranded_long_ago {

120 continue;

121 }

122 let sb = sandbox::Entity::find()

123 .filter(sandbox::Column::RunId.eq(r.id))

124 .order_by_desc(sandbox::Column::CreatedAt)

125 .one(db.read())

126 .await?;

127 let stranded = match &sb {

128 None => true,

129 Some(s) => matches!(

130 s.state,

131 AgentSandboxState::Killed | AgentSandboxState::Lost

132 ),

133 };

134 if !stranded {

135 continue;

136 }

137 let now = OffsetDateTime::now_utc();

138 run::Entity::update_many()

139 .col_expr(run::Column::State, Expr::value(AgentRunState::Failure))

140 .col_expr(

141 run::Column::Error,

142 Expr::value(Some("sandbox lost".to_string())),

143 )

144 .col_expr(run::Column::FinishedAt, Expr::value(Some(now)))

145 .col_expr(run::Column::UpdatedAt, Expr::value(now))

146 .filter(run::Column::Id.eq(r.id))

147 .filter(run::Column::State.eq(AgentRunState::Running))

148 .exec(db.write())

149 .await?;

150 if let Err(e) = sink

151 .append(

152 r.id,

153 &RunEvent::RunError {

154 message: "sandbox lost".to_string(),

155 },

156 )

157 .await

158 {

159 tracing::warn!(run_id = %r.id, error = %e, "failed to record sandbox-lost event");

160 }

161 report.failed_runs += 1;

162 }

163

164 Ok(report)

165}

166

167async fn mark_sandbox(

168 db: &export::AppDatabase,

169 row_id: uuid::Uuid,

170 state: AgentSandboxState,

171) {

172 if let Err(e) =

173 super::persist::set_sandbox_state(db, row_id, state, Some(OffsetDateTime::now_utc())).await

174 {

175 tracing::warn!(error = %e, "failed to update agent sandbox state");

176 }

177}

Added lib/agent/src/runtime/sandbox.rs +154 −0 View lib/agent/src/runtime/sandbox.rs

@@ -0,0 +1,154 @@

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}

Added lib/agent/src/runtime/sink.rs +143 −0 View lib/agent/src/runtime/sink.rs

@@ -0,0 +1,143 @@

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}

Added lib/agent/src/tools/artifact.rs +163 −0 View lib/agent/src/tools/artifact.rs

@@ -0,0 +1,163 @@

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}

Added lib/agent/src/tools/files.rs +146 −0 View lib/agent/src/tools/files.rs

@@ -0,0 +1,146 @@

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}

Added lib/agent/src/tools/mod.rs +51 −0 View lib/agent/src/tools/mod.rs

@@ -0,0 +1,51 @@

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}

Added lib/agent/src/tools/shell.rs +65 −0 View lib/agent/src/tools/shell.rs

@@ -0,0 +1,65 @@

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}

Added lib/agent/src/error.rs +25 −0 View lib/agent/src/error.rs

@@ -0,0 +1,25 @@

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>;

Added lib/agent/src/lib.rs +3 −0 View lib/agent/src/lib.rs

@@ -0,0 +1,3 @@

1pub mod error;

2pub mod runtime;

3pub mod tools;

Added lib/agent/Cargo.toml +21 −0 View lib/agent/Cargo.toml

@@ -0,0 +1,21 @@

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 }

Added lib/config/src/agent.rs +112 −0 View lib/config/src/agent.rs

@@ -0,0 +1,112 @@

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}

43

44impl Default for AgentRuntimeConfig {

45 fn default() -> Self {

46 Self {

47 default_max_turns: 32,

48 event_stream_maxlen: 10_000,

49 event_ttl_secs: 86_400,

50 tool_output_max_bytes: 32_768,

51 artifact_max_size: 104_857_600,

52 artifact_dir: String::new(),

53 }

54 }

55}

56

57#[derive(Clone, Debug, Default, Deserialize)]

58#[serde(default)]

59pub struct AgentConfig {

60 pub provider: AgentProviderConfig,

61 pub sandbox: AgentSandboxConfig,

62 pub runtime: AgentRuntimeConfig,

63}

64

65impl AgentConfig {

66 pub fn is_enabled(&self) -> bool {

67 !self.provider.base_url.is_empty()

68 || !self.provider.model.is_empty()

69 || !self.sandbox.api_url.is_empty()

70 || !self.sandbox.template_id.is_empty()

71 }

72

73 pub fn is_valid(&self) -> Result<(), String> {

74 if !self.is_enabled() {

75 return Ok(());

76 }

77 if self.provider.base_url.is_empty() {

78 return Err("agent provider base_url must be set".to_string());

79 }

80 if self.provider.model.is_empty() {

81 return Err("agent provider model must be set".to_string());

82 }

83 if self.sandbox.api_url.is_empty() {

84 return Err("agent sandbox api_url must be set".to_string());

85 }

86 if self.sandbox.api_key.is_empty() {

87 return Err("agent sandbox api_key must be set".to_string());

88 }

89 if self.sandbox.template_id.is_empty() {

90 return Err("agent sandbox template_id must be set".to_string());

91 }

92 if self.sandbox.timeout_secs == 0 || self.sandbox.lease_secs == 0 {

93 return Err("agent sandbox timeouts must be positive".to_string());

94 }

95 if self.sandbox.lease_secs > self.sandbox.timeout_secs {

96 return Err("agent sandbox lease_secs must not exceed timeout_secs".to_string());

97 }

98 if self.runtime.default_max_turns == 0 {

99 return Err("agent runtime default_max_turns must be positive".to_string());

100 }

101 if self.runtime.event_stream_maxlen == 0 {

102 return Err("agent runtime event_stream_maxlen must be positive".to_string());

103 }

104 if self.runtime.tool_output_max_bytes == 0 {

105 return Err("agent runtime tool_output_max_bytes must be positive".to_string());

106 }

107 if self.runtime.artifact_max_size <= 0 {

108 return Err("agent runtime artifact_max_size must be positive".to_string());

109 }

110 Ok(())

111 }

112}

Modified lib/config/src/lib.rs +4 −0 View lib/config/src/lib.rs

@@ -1,3 +1,4 @@

1pub mod agent;

12pub mod apihost;

23pub mod auth;

34pub mod cache;

@@ -22,6 +23,7 @@

2223

2324pub use error::ConfigError;

2425

26use crate::agent::AgentConfig;

2527use crate::apihost::ApihostConfig;

2628use crate::auth::AuthConfig;

2729use crate::cache::CacheConfig;

@@ -62,6 +64,7 @@

6264 pub email_queue: EmailQueueConfig,

6365 pub apihost: ApihostConfig,

6466 pub githost: GithostConfig,

67 pub agent: AgentConfig,

6568}

6669

6770impl AppConfig {

@@ -83,6 +86,7 @@

8386 self.session.is_valid().map_err(ConfigError::Validation)?;

8487 self.apihost.is_valid().map_err(ConfigError::Validation)?;

8588 self.githost.is_valid().map_err(ConfigError::Validation)?;

89 self.agent.is_valid().map_err(ConfigError::Validation)?;

8690 Ok(())

8791 }

8892}

Added lib/models/src/agent/agent.rs +23 −0 View lib/models/src/agent/agent.rs

@@ -0,0 +1,23 @@

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 {}

Added lib/models/src/agent/artifact.rs +50 −0 View lib/models/src/agent/artifact.rs

@@ -0,0 +1,50 @@

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 {}

Added lib/models/src/agent/conversation.rs +27 −0 View lib/models/src/agent/conversation.rs

@@ -0,0 +1,27 @@

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 {}

Added lib/models/src/agent/mod.rs +7 −0 View lib/models/src/agent/mod.rs

@@ -0,0 +1,7 @@

1#![allow(clippy::module_inception)]

2

3pub mod agent;

4pub mod artifact;

5pub mod conversation;

6pub mod run;

7pub mod sandbox;

Added lib/models/src/agent/run.rs +62 −0 View lib/models/src/agent/run.rs

@@ -0,0 +1,62 @@

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 {}

Added lib/models/src/agent/sandbox.rs +55 −0 View lib/models/src/agent/sandbox.rs

@@ -0,0 +1,55 @@

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 +1 −0 View lib/models/src/lib.rs

@@ -1,3 +1,4 @@

1pub mod agent;

12pub mod chat;

23pub mod common;

34pub mod dir;

Modified lib/models/schema_extras.sql +11 −0 View lib/models/schema_extras.sql

@@ -262,3 +262,14 @@

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 +5949 −2032 View Cargo.lock

@@ -87,6 +87,27 @@

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]]

90111name = "ahash"

91112version = "0.7.8"

92113source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -107,6 +128,7 @@

107128 "const-random",

108129 "getrandom 0.3.4",

109130 "once_cell",

131 "serde",

110132 "version_check 0.9.5",

111133 "zerocopy",

112134]

@@ -127,6 +149,39 @@

127149checksum = "250f629c0161ad8107cf89319e990051fae62832fd343083bea452d93e2205fd"

128150

129151[[package]]

152name = "aligned"

153version = "0.4.3"

154source = "registry+https://github.com/rust-lang/crates.io-index"

155checksum = "ee4508988c62edf04abd8d92897fca0c2995d907ce1dfeaf369dac3716a40685"

156dependencies = [

157 "as-slice",

158]

159

160[[package]]

161name = "aligned-vec"

162version = "0.6.4"

163source = "registry+https://github.com/rust-lang/crates.io-index"

164checksum = "dc890384c8602f339876ded803c97ad529f3842aba97f6392b3dba0dd171769b"

165dependencies = [

166 "equator",

167]

168

169[[package]]

170name = "alloc-no-stdlib"

171version = "2.0.4"

172source = "registry+https://github.com/rust-lang/crates.io-index"

173checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3"

174

175[[package]]

176name = "alloc-stdlib"

177version = "0.2.4"

178source = "registry+https://github.com/rust-lang/crates.io-index"

179checksum = "0e76a019e91224d279006ff972f1e984179a6e9feb050adba6ce8274aef23195"

180dependencies = [

181 "alloc-no-stdlib",

182]

183

184[[package]]

130185name = "allocator-api2"

131186version = "0.2.21"

132187source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -206,18 +261,35 @@

206261checksum = "03918c3dbd7701a85c6b9887732e2921175f26c350b4563841d0958c21d57e6d"

207262

208263[[package]]

264name = "arg_enum_proc_macro"

265version = "0.3.4"

266source = "registry+https://github.com/rust-lang/crates.io-index"

267checksum = "0ae92a5119aa49cdbcf6b9f893fe4e1d98b04ccbf82ee0584ad948a44a734dea"

268dependencies = [

269 "proc-macro2",

270 "quote",

271 "syn 2.0.119",

272]

273

274[[package]]

209275name = "argon2"

210276version = "0.6.0"

211277source = "registry+https://github.com/rust-lang/crates.io-index"

212278checksum = "134c52ddac6d63c576bef8168db10c83c49c26444ecbc68060fef078925a901c"

213279dependencies = [

214280 "base64ct",

215 "blake2",

281 "blake2 0.11.0",

216282 "cpufeatures 0.3.0",

217283 "password-hash",

218284]

219285

220286[[package]]

287name = "arrayref"

288version = "0.3.9"

289source = "registry+https://github.com/rust-lang/crates.io-index"

290checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"

291

292[[package]]

221293name = "arrayvec"

222294version = "0.7.8"

223295source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -233,7 +305,10 @@

233305 "arrow-array",

234306 "arrow-buffer",

235307 "arrow-cast",

308 "arrow-csv",

236309 "arrow-data",

310 "arrow-ipc",

311 "arrow-json",

237312 "arrow-ord",

238313 "arrow-row",

239314 "arrow-schema",

@@ -266,6 +341,7 @@

266341 "arrow-data",

267342 "arrow-schema",

268343 "chrono",

344 "chrono-tz",

269345 "half",

270346 "hashbrown 0.17.1",

271347 "num-complex",

@@ -300,6 +376,7 @@

300376 "atoi",

301377 "base64 0.22.1",

302378 "chrono",

379 "comfy-table",

303380 "half",

304381 "lexical-core",

305382 "num-traits",

@@ -307,6 +384,21 @@

307384]

308385

309386[[package]]

387name = "arrow-csv"

388version = "58.4.0"

389source = "registry+https://github.com/rust-lang/crates.io-index"

390checksum = "af0dd6d90d1955e9f9a014c1e563ee8aeffc21909085d25623e1da44d96eca26"

391dependencies = [

392 "arrow-array",

393 "arrow-cast",

394 "arrow-schema",

395 "chrono",

396 "csv",

397 "csv-core",

398 "regex",

399]

400

401[[package]]

310402name = "arrow-data"

311403version = "58.4.0"

312404source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -320,6 +412,47 @@

320412]

321413

322414[[package]]

415name = "arrow-ipc"

416version = "58.4.0"

417source = "registry+https://github.com/rust-lang/crates.io-index"

418checksum = "29a908a11fcfb3fb2f6730f4ac15e367bc644e419155e96238f68cf3adde572b"

419dependencies = [

420 "arrow-array",

421 "arrow-buffer",

422 "arrow-data",

423 "arrow-schema",

424 "arrow-select",

425 "flatbuffers",

426 "lz4_flex",

427 "zstd",

428]

429

430[[package]]

431name = "arrow-json"

432version = "58.4.0"

433source = "registry+https://github.com/rust-lang/crates.io-index"

434checksum = "b8a96aed3931c076adee39ec2a40d8219fc7f09e79bcdaca1df16272993e1e14"

435dependencies = [

436 "arrow-array",

437 "arrow-buffer",

438 "arrow-cast",

439 "arrow-ord",

440 "arrow-schema",

441 "arrow-select",

442 "chrono",

443 "half",

444 "indexmap 2.14.0",

445 "itoa",

446 "lexical-core",

447 "memchr",

448 "num-traits",

449 "ryu",

450 "serde_core",

451 "serde_json",

452 "simdutf8",

453]

454

455[[package]]

323456name = "arrow-ord"

324457version = "58.4.0"

325458source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -350,6 +483,11 @@

350483version = "58.4.0"

351484source = "registry+https://github.com/rust-lang/crates.io-index"

352485checksum = "21ca356ad6425cecb6eb7b28e4f659f1ee7880fbb1a16127de7dd62901efee9e"

486dependencies = [

487 "bitflags 2.13.1",

488 "serde_core",

489 "serde_json",

490]

353491

354492[[package]]

355493name = "arrow-select"

@@ -383,12 +521,51 @@

383521]

384522

385523[[package]]

524name = "as-any"

525version = "0.3.2"

526source = "registry+https://github.com/rust-lang/crates.io-index"

527checksum = "b0f477b951e452a0b6b4a10b53ccd569042d1d01729b519e02074a9c0958a063"

528

529[[package]]

530name = "as-slice"

531version = "0.2.1"

532source = "registry+https://github.com/rust-lang/crates.io-index"

533checksum = "516b6b4f0e40d50dcda9365d53964ec74560ad4284da2e7fc97122cd83174516"

534dependencies = [

535 "stable_deref_trait",

536]

537

538[[package]]

386539name = "ascii_utils"

387540version = "0.9.3"

388541source = "registry+https://github.com/rust-lang/crates.io-index"

389542checksum = "71938f30533e4d95a6d17aa530939da3842c2ab6f4f84b9dae68447e4129f74a"

390543

391544[[package]]

545name = "async-channel"

546version = "2.5.0"

547source = "registry+https://github.com/rust-lang/crates.io-index"

548checksum = "924ed96dd52d1b75e9c1a3e6275715fd320f5f9439fb5a4a11fa51f4221158d2"

549dependencies = [

550 "concurrent-queue",

551 "event-listener-strategy",

552 "futures-core",

553 "pin-project-lite",

554]

555

556[[package]]

557name = "async-compression"

558version = "0.4.45"

559source = "registry+https://github.com/rust-lang/crates.io-index"

560checksum = "24a8ec73eb862508b7041723c89386365894b4e7d9f6998bf1b8529e5b0ee254"

561dependencies = [

562 "compression-codecs",

563 "compression-core",

564 "pin-project-lite",

565 "tokio",

566]

567

568[[package]]

392569name = "async-graphql"

393570version = "7.2.1"

394571source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -407,7 +584,7 @@

407584 "futures-util",

408585 "handlebars",

409586 "http 1.5.0",

410 "indexmap",

587 "indexmap 2.14.0",

411588 "mime 0.3.17",

412589 "multer",

413590 "num-traits",

@@ -457,7 +634,7 @@

457634checksum = "3e3ef112905abea9dea592fc868a6873b10ebd3f983e83308f995d6284e9ba41"

458635dependencies = [

459636 "bytes",

460 "indexmap",

637 "indexmap 2.14.0",

461638 "serde",

462639 "serde_json",

463640]

@@ -492,6 +669,17 @@

492669]

493670

494671[[package]]

672name = "async-recursion"

673version = "1.1.1"

674source = "registry+https://github.com/rust-lang/crates.io-index"

675checksum = "3b43422f69d8ff38f95f1b2bb76517c91589a924d1559a0e935d7c8ce0274c11"

676dependencies = [

677 "proc-macro2",

678 "quote",

679 "syn 2.0.119",

680]

681

682[[package]]

495683name = "async-stream"

496684version = "0.3.6"

497685source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -525,6 +713,15 @@

525713]

526714

527715[[package]]

716name = "async_cell"

717version = "0.2.3"

718source = "registry+https://github.com/rust-lang/crates.io-index"

719checksum = "447ab28afbb345f5408b120702a44e5529ebf90b1796ec76e9528df8e288e6c2"

720dependencies = [

721 "loom",

722]

723

724[[package]]

528725name = "asynk-strim"

529726version = "0.1.5"

530727source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -614,13 +811,56 @@

614811checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"

615812

616813[[package]]

814name = "av-scenechange"

815version = "0.14.1"

816source = "registry+https://github.com/rust-lang/crates.io-index"

817checksum = "0f321d77c20e19b92c39e7471cf986812cbb46659d2af674adc4331ef3f18394"

818dependencies = [

819 "aligned",

820 "anyhow",

821 "arg_enum_proc_macro",

822 "arrayvec",

823 "log 0.4.33",

824 "num-rational",

825 "num-traits",

826 "pastey 0.1.1",

827 "rayon",

828 "thiserror 2.0.20",

829 "v_frame",

830 "y4m",

831]

832

833[[package]]

834name = "av1-grain"

835version = "0.2.5"

836source = "registry+https://github.com/rust-lang/crates.io-index"

837checksum = "8cfddb07216410377231960af4fcab838eaa12e013417781b78bd95ee22077f8"

838dependencies = [

839 "anyhow",

840 "arrayvec",

841 "log 0.4.33",

842 "nom 8.0.0",

843 "num-rational",

844 "v_frame",

845]

846

847[[package]]

848name = "avif-serialize"

849version = "0.8.9"

850source = "registry+https://github.com/rust-lang/crates.io-index"

851checksum = "e7178fe5f7d460b13895ebb9dcb28a3a6216d2df2574a0806cb51b555d297f38"

852dependencies = [

853 "arrayvec",

854]

855

856[[package]]

617857name = "aws-creds"

618858version = "0.35.0"

619859source = "registry+https://github.com/rust-lang/crates.io-index"

620860checksum = "01eb8a458c003bd8fe37badba2d8a5a3839748b6ade5cc2d92c2c6b9c6d5a437"

621861dependencies = [

622862 "attohttpc",

623 "dirs",

863 "dirs 5.0.1",

624864 "log 0.4.33",

625865 "quick-xml",

626866 "rust-ini",

@@ -797,6 +1037,12 @@

7971037

7981038[[package]]

7991039name = "base64"

1040version = "0.13.1"

1041source = "registry+https://github.com/rust-lang/crates.io-index"

1042checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"

1043

1044[[package]]

1045name = "base64"

8001046version = "0.21.7"

8011047source = "registry+https://github.com/rust-lang/crates.io-index"

8021048checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"

@@ -860,6 +1106,12 @@

8601106checksum = "d21f40d350a700f6aa107e45fb26448cf489d34794b2ba4522181dc9f1173af6"

8611107

8621108[[package]]

1109name = "bit_field"

1110version = "0.10.3"

1111source = "registry+https://github.com/rust-lang/crates.io-index"

1112checksum = "1e4b40c7323adcfc0a41c4b88143ed58346ff65a288fc144329c5c45e05d70c6"

1113

1114[[package]]

8631115name = "bitflags"

8641116version = "1.3.2"

8651117source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -875,6 +1127,24 @@

8751127]

8761128

8771129[[package]]

1130name = "bitpacking"

1131version = "0.9.3"

1132source = "registry+https://github.com/rust-lang/crates.io-index"

1133checksum = "96a7139abd3d9cebf8cd6f920a389cf3dc9576172e32f4563f188cae3c3eb019"

1134dependencies = [

1135 "crunchy",

1136]

1137

1138[[package]]

1139name = "bitstream-io"

1140version = "4.10.0"

1141source = "registry+https://github.com/rust-lang/crates.io-index"

1142checksum = "7eff00be299a18769011411c9def0d827e8f2d7bf0c3dbf53633147a8867fd1f"

1143dependencies = [

1144 "no_std_io2",

1145]

1146

1147[[package]]

8781148name = "bitvec"

8791149version = "1.1.1"

8801150source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -888,6 +1158,15 @@

8881158

8891159[[package]]

8901160name = "blake2"

1161version = "0.10.6"

1162source = "registry+https://github.com/rust-lang/crates.io-index"

1163checksum = "46502ad458c9a52b69d4d4d32775c788b7a1b85e8bc9d482d92250fc0e3f8efe"

1164dependencies = [

1165 "digest 0.10.7",

1166]

1167

1168[[package]]

1169name = "blake2"

8911170version = "0.11.0"

8921171source = "registry+https://github.com/rust-lang/crates.io-index"

8931172checksum = "5b5d4d889834ee8ecfc0f8426ad30faf7cdcb10f741a8e6d7224d95325479f6f"

@@ -896,6 +1175,19 @@

8961175]

8971176

8981177[[package]]

1178name = "blake3"

1179version = "1.8.7"

1180source = "registry+https://github.com/rust-lang/crates.io-index"

1181checksum = "6d9e454fc11f76977dc803893aff6304ed33d6a26efae8696573bea74baa27ae"

1182dependencies = [

1183 "arrayvec",

1184 "cc",

1185 "cfg-if",

1186 "constant_time_eq",

1187 "cpufeatures 0.3.0",

1188]

1189

1190[[package]]

8991191name = "block-buffer"

9001192version = "0.10.4"

9011193source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -958,6 +1250,36 @@

9581250]

9591251

9601252[[package]]

1253name = "brotli"

1254version = "8.0.4"

1255source = "registry+https://github.com/rust-lang/crates.io-index"

1256checksum = "5cc91aac060a7a1e25823bdccbfb6af1875b88f17c6daac97894eed8207166b3"

1257dependencies = [

1258 "alloc-no-stdlib",

1259 "alloc-stdlib",

1260 "brotli-decompressor",

1261]

1262

1263[[package]]

1264name = "brotli-decompressor"

1265version = "5.0.3"

1266source = "registry+https://github.com/rust-lang/crates.io-index"

1267checksum = "3a32acac15fe1967bc3986b2a6347dffc965602354ea6f450ad07e8bfd253583"

1268dependencies = [

1269 "alloc-no-stdlib",

1270 "alloc-stdlib",

1271]

1272

1273[[package]]

1274name = "bs58"

1275version = "0.5.1"

1276source = "registry+https://github.com/rust-lang/crates.io-index"

1277checksum = "bf88ba1141d185c399bee5288d850d63b8369520c1eafc32a0430b5b6c287bf4"

1278dependencies = [

1279 "tinyvec",

1280]

1281

1282[[package]]

9611283name = "bstr"

9621284version = "1.13.1"

9631285source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -969,6 +1291,12 @@

9691291]

9701292

9711293[[package]]

1294name = "built"

1295version = "0.8.1"

1296source = "registry+https://github.com/rust-lang/crates.io-index"

1297checksum = "5c0e531d93d39c34eef561e929e8a7f86d77a5af08aac4f6d6e39976c51858e9"

1298

1299[[package]]

9721300name = "bumpalo"

9731301version = "3.20.3"

9741302source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -980,8 +1308,20 @@

9801308source = "registry+https://github.com/rust-lang/crates.io-index"

9811309checksum = "23cdc57ce23ac53c931e88a43d06d070a6fd142f2617be5855eb75efc9beb1c2"

9821310dependencies = [

983 "bytecheck_derive",

984 "ptr_meta",

1311 "bytecheck_derive 0.6.12",

1312 "ptr_meta 0.1.4",

1313 "simdutf8",

1314]

1315

1316[[package]]

1317name = "bytecheck"

1318version = "0.8.3"

1319source = "registry+https://github.com/rust-lang/crates.io-index"

1320checksum = "26333eeac754f0ad8a6bcd0eb0ac012156302e4e16b852b72ee399aea4f12c29"

1321dependencies = [

1322 "bytecheck_derive 0.8.3",

1323 "ptr_meta 0.3.2",

1324 "rancor",

9851325 "simdutf8",

9861326]

9871327

@@ -997,6 +1337,17 @@

9971337]

9981338

9991339[[package]]

1340name = "bytecheck_derive"

1341version = "0.8.3"

1342source = "registry+https://github.com/rust-lang/crates.io-index"

1343checksum = "46d07918caa9eeaaf06b7873925c53a61daac173539b4f7715090745e44e4e69"

1344dependencies = [

1345 "proc-macro2",

1346 "quote",

1347 "syn 3.0.3",

1348]

1349

1350[[package]]

10001351name = "bytemuck"

10011352version = "1.25.2"

10021353source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -1009,6 +1360,12 @@

10091360checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"

10101361

10111362[[package]]

1363name = "byteorder-lite"

1364version = "0.1.0"

1365source = "registry+https://github.com/rust-lang/crates.io-index"

1366checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495"

1367

1368[[package]]

10121369name = "bytes"

10131370version = "1.12.1"

10141371source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -1045,7 +1402,16 @@

10451402]

10461403

10471404[[package]]

1048name = "cbc"

1405name = "castaway"

1406version = "0.2.4"

1407source = "registry+https://github.com/rust-lang/crates.io-index"

1408checksum = "dec551ab6e7578819132c713a93c022a05d60159dc86e7a7050223577484c55a"

1409dependencies = [

1410 "rustversion",

1411]

1412

1413[[package]]

1414name = "cbc"

10491415version = "0.2.1"

10501416source = "registry+https://github.com/rust-lang/crates.io-index"

10511417checksum = "ce2dc9ee5f88d11e0beb842c88b33c8a5cf0d1329c4b19494af42b07dbfe8896"

@@ -1066,6 +1432,15 @@

10661432]

10671433

10681434[[package]]

1435name = "cedarwood"

1436version = "0.4.6"

1437source = "registry+https://github.com/rust-lang/crates.io-index"

1438checksum = "6d910bedd62c24733263d0bed247460853c9d22e8956bd4cd964302095e04e90"

1439dependencies = [

1440 "smallvec",

1441]

1442

1443[[package]]

10691444name = "cfg-if"

10701445version = "1.0.4"

10711446source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -1137,6 +1512,16 @@

11371512]

11381513

11391514[[package]]

1515name = "chrono-tz"

1516version = "0.10.4"

1517source = "registry+https://github.com/rust-lang/crates.io-index"

1518checksum = "a6139a8597ed92cf816dfb33f5dd6cf0bb93a6adc938f11039f371bc5bcd26c3"

1519dependencies = [

1520 "chrono",

1521 "phf 0.12.1",

1522]

1523

1524[[package]]

11401525name = "cipher"

11411526version = "0.4.4"

11421527source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -1189,6 +1574,12 @@

11891574checksum = "d7ee2cfacbd29706479902b06d75ad8f1362900836aa32799eabc7e004bfd854"

11901575

11911576[[package]]

1577name = "color_quant"

1578version = "1.1.0"

1579source = "registry+https://github.com/rust-lang/crates.io-index"

1580checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"

1581

1582[[package]]

11921583name = "combine"

11931584version = "4.6.7"

11941585source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -1203,6 +1594,48 @@

12031594]

12041595

12051596[[package]]

1597name = "comfy-table"

1598version = "7.2.2"

1599source = "registry+https://github.com/rust-lang/crates.io-index"

1600checksum = "958c5d6ecf1f214b4c2bbbbf6ab9523a864bd136dcf71a7e8904799acfe1ad47"

1601dependencies = [

1602 "unicode-segmentation",

1603 "unicode-width",

1604]

1605

1606[[package]]

1607name = "compact_str"

1608version = "0.9.1"

1609source = "registry+https://github.com/rust-lang/crates.io-index"

1610checksum = "9dfdd1c2274d9aa354115b09dc9a901d6c5576818cdf70d14cae2bdb47df00ab"

1611dependencies = [

1612 "castaway",

1613 "cfg-if",

1614 "itoa",

1615 "rustversion",

1616 "ryu",

1617 "serde",

1618 "static_assertions",

1619]

1620

1621[[package]]

1622name = "compression-codecs"

1623version = "0.4.40"

1624source = "registry+https://github.com/rust-lang/crates.io-index"

1625checksum = "100590da849306918656ffbb22576bbdfc1382b50ad10d1d50ec177d3b205fb2"

1626dependencies = [

1627 "compression-core",

1628 "flate2",

1629 "memchr",

1630]

1631

1632[[package]]

1633name = "compression-core"

1634version = "0.4.33"

1635source = "registry+https://github.com/rust-lang/crates.io-index"

1636checksum = "6e8ccc4ea9f6acc32d102c0f6d471d11d913ad15f20c04de743374861fa1d414"

1637

1638[[package]]

12061639name = "concurrent-queue"

12071640version = "2.5.0"

12081641source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -1225,6 +1658,19 @@

12251658]

12261659

12271660[[package]]

1661name = "console"

1662version = "0.15.11"

1663source = "registry+https://github.com/rust-lang/crates.io-index"

1664checksum = "054ccb5b10f9f2cbf51eb355ca1d05c2d279ce1804688d0db74b4733a5aeafd8"

1665dependencies = [

1666 "encode_unicode",

1667 "libc",

1668 "once_cell",

1669 "unicode-width",

1670 "windows-sys 0.59.0",

1671]

1672

1673[[package]]

12281674name = "const-oid"

12291675version = "0.9.6"

12301676source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -1257,6 +1703,21 @@

12571703]

12581704

12591705[[package]]

1706name = "constant_time_eq"

1707version = "0.4.2"

1708source = "registry+https://github.com/rust-lang/crates.io-index"

1709checksum = "3d52eff69cd5e647efe296129160853a42795992097e8af39800e1060caeea9b"

1710

1711[[package]]

1712name = "convert_case"

1713version = "0.11.0"

1714source = "registry+https://github.com/rust-lang/crates.io-index"

1715checksum = "affbf0190ed2caf063e3def54ff444b449371d55c58e513a95ab98eca50adb49"

1716dependencies = [

1717 "unicode-segmentation",

1718]

1719

1720[[package]]

12601721name = "cookie"

12611722version = "0.18.2"

12621723source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -1273,6 +1734,16 @@

12731734

12741735[[package]]

12751736name = "core-foundation"

1737version = "0.9.4"

1738source = "registry+https://github.com/rust-lang/crates.io-index"

1739checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"

1740dependencies = [

1741 "core-foundation-sys",

1742 "libc",

1743]

1744

1745[[package]]

1746name = "core-foundation"

12761747version = "0.10.1"

12771748source = "registry+https://github.com/rust-lang/crates.io-index"

12781749checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6"

@@ -1371,6 +1842,16 @@

13711842]

13721843

13731844[[package]]

1845name = "crossbeam-deque"

1846version = "0.8.8"

1847source = "registry+https://github.com/rust-lang/crates.io-index"

1848checksum = "622f3fc73690be383c7214310406f28a90e6edeadc3cea882f9d71e495b9711a"

1849dependencies = [

1850 "crossbeam-epoch",

1851 "crossbeam-utils",

1852]

1853

1854[[package]]

13741855name = "crossbeam-epoch"

13751856version = "0.9.20"

13761857source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -1389,6 +1870,16 @@

13891870]

13901871

13911872[[package]]

1873name = "crossbeam-skiplist"

1874version = "0.1.3"

1875source = "registry+https://github.com/rust-lang/crates.io-index"

1876checksum = "df29de440c58ca2cc6e587ec3d22347551a32435fbde9d2bff64e78a9ffa151b"

1877dependencies = [

1878 "crossbeam-epoch",

1879 "crossbeam-utils",

1880]

1881

1882[[package]]

13921883name = "crossbeam-utils"

13931884version = "0.8.22"

13941885source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -1462,6 +1953,27 @@

14621953]

14631954

14641955[[package]]

1956name = "csv"

1957version = "1.4.0"

1958source = "registry+https://github.com/rust-lang/crates.io-index"

1959checksum = "52cd9d68cf7efc6ddfaaee42e7288d3a99d613d4b50f76ce9827ae0c6e14f938"

1960dependencies = [

1961 "csv-core",

1962 "itoa",

1963 "ryu",

1964 "serde_core",

1965]

1966

1967[[package]]

1968name = "csv-core"

1969version = "0.1.13"

1970source = "registry+https://github.com/rust-lang/crates.io-index"

1971checksum = "704a3c26996a80471189265814dbc2c257598b96b8a7feae2d31ace646bb9782"

1972dependencies = [

1973 "memchr",

1974]

1975

1976[[package]]

14651977name = "ctr"

14661978version = "0.9.2"

14671979source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -1490,6 +2002,23 @@

14902002]

14912003

14922004[[package]]

2005name = "cubesandbox"

2006version = "0.1.0"

2007source = "git+https://gitea.gitdata.me/GitDataAi/sanbox-client.git?rev=91ba6f56ac#91ba6f56acd3ee884326aeb4fdd77cc8881c7a7d"

2008dependencies = [

2009 "base64 0.23.1",

2010 "bytes",

2011 "chrono",

2012 "futures",

2013 "reqwest 0.13.4",

2014 "serde",

2015 "serde_json",

2016 "thiserror 2.0.20",

2017 "tokio",

2018 "url 2.5.8",

2019]

2020

2021[[package]]

14932022name = "cuckoofilter"

14942023version = "0.5.0"

14952024source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -1529,6 +2058,12 @@

15292058]

15302059

15312060[[package]]

2061name = "daachorse"

2062version = "2.1.1"

2063source = "registry+https://github.com/rust-lang/crates.io-index"

2064checksum = "db756b5eb7d81d31f31f660f4132f8cf5698de52fca144c143d0ae0cbb5f2e06"

2065

2066[[package]]

15322067name = "darling"

15332068version = "0.20.11"

15342069source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -1549,6 +2084,16 @@

15492084]

15502085

15512086[[package]]

2087name = "darling"

2088version = "0.24.1"

2089source = "registry+https://github.com/rust-lang/crates.io-index"

2090checksum = "ed17f5901b6630b993ca003def43f2f8ef4014fc13b047b57aad617ff32bc2ec"

2091dependencies = [

2092 "darling_core 0.24.1",

2093 "darling_macro 0.24.1",

2094]

2095

2096[[package]]

15522097name = "darling_core"

15532098version = "0.20.11"

15542099source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -1576,6 +2121,19 @@

15762121]

15772122

15782123[[package]]

2124name = "darling_core"

2125version = "0.24.1"

2126source = "registry+https://github.com/rust-lang/crates.io-index"

2127checksum = "6837e2cf7485aaae18f86181d2f0e9a7ed297a025e220aeabf63fdebd3a2ddff"

2128dependencies = [

2129 "ident_case",

2130 "proc-macro2",

2131 "quote",

2132 "strsim",

2133 "syn 3.0.3",

2134]

2135

2136[[package]]

15792137name = "darling_macro"

15802138version = "0.20.11"

15812139source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -1598,6 +2156,26 @@

15982156]

15992157

16002158[[package]]

2159name = "darling_macro"

2160version = "0.24.1"

2161source = "registry+https://github.com/rust-lang/crates.io-index"

2162checksum = "2ac7135c3ef02b2f7833bbeb1be5ba7f966dcde8a87c6b87f65a778d71a02785"

2163dependencies = [

2164 "darling_core 0.24.1",

2165 "quote",

2166 "syn 3.0.3",

2167]

2168

2169[[package]]

2170name = "dary_heap"

2171version = "0.3.9"

2172source = "registry+https://github.com/rust-lang/crates.io-index"

2173checksum = "8b1e3a325bc115f096c8b77bbf027a7c2592230e70be2d985be950d3d5e60ebe"

2174dependencies = [

2175 "serde",

2176]

2177

2178[[package]]

16012179name = "dashmap"

16022180version = "6.2.1"

16032181source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -1618,3118 +2196,4808 @@

16182196checksum = "4583a4551df46e2792f82ceeac45e850d2e2d5debba0b91f102385cda5b11f06"

16192197

16202198[[package]]

1621name = "defmt"

1622version = "1.1.1"

2199name = "datafusion"

2200version = "53.1.0"

16232201source = "registry+https://github.com/rust-lang/crates.io-index"

1624checksum = "e2953bfe4f93bbd20cc71198842756f77d161884c99ebbabc41d80231ded88d1"

2202checksum = "93db0e623840612f7f2cd757f7e8a8922064192363732c88692e0870016e141b"

16252203dependencies = [

1626 "bitflags 1.3.2",

1627 "defmt-macros",

2204 "arrow",

2205 "arrow-schema",

2206 "async-trait",

2207 "bytes",

2208 "chrono",

2209 "datafusion-catalog",

2210 "datafusion-catalog-listing",

2211 "datafusion-common",

2212 "datafusion-common-runtime",

2213 "datafusion-datasource",

2214 "datafusion-datasource-arrow",

2215 "datafusion-datasource-csv",

2216 "datafusion-datasource-json",

2217 "datafusion-execution",

2218 "datafusion-expr",

2219 "datafusion-expr-common",

2220 "datafusion-functions",

2221 "datafusion-functions-aggregate",

2222 "datafusion-functions-nested",

2223 "datafusion-functions-table",

2224 "datafusion-functions-window",

2225 "datafusion-optimizer",

2226 "datafusion-physical-expr",

2227 "datafusion-physical-expr-adapter",

2228 "datafusion-physical-expr-common",

2229 "datafusion-physical-optimizer",

2230 "datafusion-physical-plan",

2231 "datafusion-session",

2232 "datafusion-sql",

2233 "futures",

2234 "itertools 0.14.0",

2235 "log 0.4.33",

2236 "object_store",

2237 "parking_lot",

2238 "rand 0.9.5",

2239 "regex",

2240 "sqlparser",

2241 "tempfile",

2242 "tokio",

2243 "url 2.5.8",

2244 "uuid",

16282245]

16292246

16302247[[package]]

1631name = "defmt-macros"

1632version = "1.1.1"

2248name = "datafusion-catalog"

2249version = "53.1.0"

16332250source = "registry+https://github.com/rust-lang/crates.io-index"

1634checksum = "bad9c72e7ca2137e0dc3813245a0d282fd6daad32fd800af018306a9169b5fe8"

2251checksum = "37cefde60b26a7f4ff61e9d2ff2833322f91df2b568d7238afe67bde5bdffb66"

16352252dependencies = [

1636 "defmt-parser",

1637 "proc-macro2",

1638 "quote",

1639 "syn 2.0.119",

2253 "arrow",

2254 "async-trait",

2255 "dashmap",

2256 "datafusion-common",

2257 "datafusion-common-runtime",

2258 "datafusion-datasource",

2259 "datafusion-execution",

2260 "datafusion-expr",

2261 "datafusion-physical-expr",

2262 "datafusion-physical-plan",

2263 "datafusion-session",

2264 "futures",

2265 "itertools 0.14.0",

2266 "log 0.4.33",

2267 "object_store",

2268 "parking_lot",

2269 "tokio",

16402270]

16412271

16422272[[package]]

1643name = "defmt-parser"

1644version = "1.0.0"

2273name = "datafusion-catalog-listing"

2274version = "53.1.0"

16452275source = "registry+https://github.com/rust-lang/crates.io-index"

1646checksum = "10d60334b3b2e7c9d91ef8150abfb6fa4c1c39ebbcf4a81c2e346aad939fee3e"

2276checksum = "17e112307715d6a7a331111a4c2330ff54bc237183511c319e3708a4cff431fb"

16472277dependencies = [

1648 "thiserror 2.0.20",

2278 "arrow",

2279 "async-trait",

2280 "datafusion-catalog",

2281 "datafusion-common",

2282 "datafusion-datasource",

2283 "datafusion-execution",

2284 "datafusion-expr",

2285 "datafusion-physical-expr",

2286 "datafusion-physical-expr-adapter",

2287 "datafusion-physical-expr-common",

2288 "datafusion-physical-plan",

2289 "futures",

2290 "itertools 0.14.0",

2291 "log 0.4.33",

2292 "object_store",

16492293]

16502294

16512295[[package]]

1652name = "delegate"

1653version = "0.13.5"

2296name = "datafusion-common"

2297version = "53.1.0"

16542298source = "registry+https://github.com/rust-lang/crates.io-index"

1655checksum = "780eb241654bf097afb00fc5f054a09b687dad862e485fdcf8399bb056565370"

2299checksum = "d72a11ca44a95e1081870d3abb80c717496e8a7acb467a1d3e932bb636af5cc2"

16562300dependencies = [

1657 "proc-macro2",

1658 "quote",

1659 "syn 2.0.119",

2301 "ahash 0.8.12",

2302 "arrow",

2303 "arrow-ipc",

2304 "chrono",

2305 "half",

2306 "hashbrown 0.16.1",

2307 "indexmap 2.14.0",

2308 "itertools 0.14.0",

2309 "libc",

2310 "log 0.4.33",

2311 "object_store",

2312 "paste",

2313 "sqlparser",

2314 "tokio",

2315 "web-time",

16602316]

16612317

16622318[[package]]

1663name = "der"

1664version = "0.7.10"

2319name = "datafusion-common-runtime"

2320version = "53.1.0"

16652321source = "registry+https://github.com/rust-lang/crates.io-index"

1666checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb"

2322checksum = "89f4afaed29670ec4fd6053643adc749fe3f4bc9d1ce1b8c5679b22c67d12def"

16672323dependencies = [

1668 "const-oid 0.9.6",

1669 "zeroize",

2324 "futures",

2325 "log 0.4.33",

2326 "tokio",

16702327]

16712328

16722329[[package]]

1673name = "der"

1674version = "0.8.1"

2330name = "datafusion-datasource"

2331version = "53.1.0"

16752332source = "registry+https://github.com/rust-lang/crates.io-index"

1676checksum = "a69dedd701da44b0536442edf09c81a64b0ab97a7a4a5e3d1971f00027cbc63d"

2333checksum = "e9fb386e1691355355a96419978a0022b7947b44d4a24a6ea99f00b6b485cbb6"

16772334dependencies = [

1678 "const-oid 0.10.2",

1679 "pem-rfc7468 1.0.0",

1680 "zeroize",

2335 "arrow",

2336 "async-trait",

2337 "bytes",

2338 "chrono",

2339 "datafusion-common",

2340 "datafusion-common-runtime",

2341 "datafusion-execution",

2342 "datafusion-expr",

2343 "datafusion-physical-expr",

2344 "datafusion-physical-expr-adapter",

2345 "datafusion-physical-expr-common",

2346 "datafusion-physical-plan",

2347 "datafusion-session",

2348 "futures",

2349 "glob",

2350 "itertools 0.14.0",

2351 "log 0.4.33",

2352 "object_store",

2353 "rand 0.9.5",

2354 "tokio",

2355 "url 2.5.8",

16812356]

16822357

16832358[[package]]

1684name = "deranged"

1685version = "0.5.8"

2359name = "datafusion-datasource-arrow"

2360version = "53.1.0"

16862361source = "registry+https://github.com/rust-lang/crates.io-index"

1687checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"

2362checksum = "ffa6c52cfed0734c5f93754d1c0175f558175248bf686c944fb05c373e5fc096"

16882363dependencies = [

1689 "serde_core",

1690]

1691

1692[[package]]

1693name = "derive-where"

1694version = "1.6.1"

2364 "arrow",

2365 "arrow-ipc",

2366 "async-trait",

2367 "bytes",

2368 "datafusion-common",

2369 "datafusion-common-runtime",

2370 "datafusion-datasource",

2371 "datafusion-execution",

2372 "datafusion-expr",

2373 "datafusion-physical-expr-common",

2374 "datafusion-physical-plan",

2375 "datafusion-session",

2376 "futures",

2377 "itertools 0.14.0",

2378 "object_store",

2379 "tokio",

2380]

2381

2382[[package]]

2383name = "datafusion-datasource-csv"

2384version = "53.1.0"

16952385source = "registry+https://github.com/rust-lang/crates.io-index"

1696checksum = "d08b3a0bcc0d079199cd476b2cae8435016ec11d1c0986c6901c5ac223041534"

2386checksum = "503f29e0582c1fc189578d665ff57d9300da1f80c282777d7eb67bb79fb8cdca"

16972387dependencies = [

1698 "proc-macro2",

1699 "quote",

1700 "syn 2.0.119",

2388 "arrow",

2389 "async-trait",

2390 "bytes",

2391 "datafusion-common",

2392 "datafusion-common-runtime",

2393 "datafusion-datasource",

2394 "datafusion-execution",

2395 "datafusion-expr",

2396 "datafusion-physical-expr-common",

2397 "datafusion-physical-plan",

2398 "datafusion-session",

2399 "futures",

2400 "object_store",

2401 "regex",

2402 "tokio",

17012403]

17022404

17032405[[package]]

1704name = "derive_arbitrary"

1705version = "1.4.2"

2406name = "datafusion-datasource-json"

2407version = "53.1.0"

17062408source = "registry+https://github.com/rust-lang/crates.io-index"

1707checksum = "1e567bd82dcff979e4b03460c307b3cdc9e96fde3d73bed1496d2bc75d9dd62a"

2409checksum = "e33804749abc8d0c8cb7473228483cb8070e524c6f6086ee1b85a64debe2b3d2"

17082410dependencies = [

1709 "proc-macro2",

1710 "quote",

1711 "syn 2.0.119",

2411 "arrow",

2412 "async-trait",

2413 "bytes",

2414 "datafusion-common",

2415 "datafusion-common-runtime",

2416 "datafusion-datasource",

2417 "datafusion-execution",

2418 "datafusion-expr",

2419 "datafusion-physical-expr-common",

2420 "datafusion-physical-plan",

2421 "datafusion-session",

2422 "futures",

2423 "object_store",

2424 "serde_json",

2425 "tokio",

2426 "tokio-stream",

17122427]

17132428

17142429[[package]]

1715name = "derive_builder"

1716version = "0.20.2"

2430name = "datafusion-doc"

2431version = "53.1.0"

2432source = "registry+https://github.com/rust-lang/crates.io-index"

2433checksum = "8de6ac0df1662b9148ad3c987978b32cbec7c772f199b1d53520c8fa764a87ee"

2434

2435[[package]]

2436name = "datafusion-execution"

2437version = "53.1.0"

17172438source = "registry+https://github.com/rust-lang/crates.io-index"

1718checksum = "507dfb09ea8b7fa618fcf76e953f4f5e192547945816d5358edffe39f6f94947"

2439checksum = "c03c7fbdaefcca4ef6ffe425a5fc2325763bfb426599bb0bf4536466efabe709"

17192440dependencies = [

1720 "derive_builder_macro",

2441 "arrow",

2442 "arrow-buffer",

2443 "async-trait",

2444 "chrono",

2445 "dashmap",

2446 "datafusion-common",

2447 "datafusion-expr",

2448 "datafusion-physical-expr-common",

2449 "futures",

2450 "log 0.4.33",

2451 "object_store",

2452 "parking_lot",

2453 "rand 0.9.5",

2454 "tempfile",

2455 "url 2.5.8",

17212456]

17222457

17232458[[package]]

1724name = "derive_builder_core"

1725version = "0.20.2"

2459name = "datafusion-expr"

2460version = "53.1.0"

17262461source = "registry+https://github.com/rust-lang/crates.io-index"

1727checksum = "2d5bcf7b024d6835cfb3d473887cd966994907effbe9227e8c8219824d06c4e8"

2462checksum = "574b9b6977fedbd2a611cbff12e5caf90f31640ad9dc5870f152836d94bad0dd"

17282463dependencies = [

1729 "darling 0.20.11",

1730 "proc-macro2",

1731 "quote",

1732 "syn 2.0.119",

2464 "arrow",

2465 "async-trait",

2466 "chrono",

2467 "datafusion-common",

2468 "datafusion-doc",

2469 "datafusion-expr-common",

2470 "datafusion-functions-aggregate-common",

2471 "datafusion-functions-window-common",

2472 "datafusion-physical-expr-common",

2473 "indexmap 2.14.0",

2474 "itertools 0.14.0",

2475 "paste",

2476 "serde_json",

2477 "sqlparser",

17332478]

17342479

17352480[[package]]

1736name = "derive_builder_macro"

1737version = "0.20.2"

2481name = "datafusion-expr-common"

2482version = "53.1.0"

17382483source = "registry+https://github.com/rust-lang/crates.io-index"

1739checksum = "ab63b0e2bf4d5928aff72e83a7dace85d7bba5fe12dcc3c5a572d78caffd3f3c"

2484checksum = "7d7c3adf3db8bf61e92eb90cb659c8e8b734593a8f7c8e12a843c7ddba24b87e"

17402485dependencies = [

1741 "derive_builder_core",

1742 "syn 2.0.119",

2486 "arrow",

2487 "datafusion-common",

2488 "indexmap 2.14.0",

2489 "itertools 0.14.0",

2490 "paste",

17432491]

17442492

17452493[[package]]

1746name = "derive_more"

1747version = "2.1.1"

2494name = "datafusion-functions"

2495version = "53.1.0"

17482496source = "registry+https://github.com/rust-lang/crates.io-index"

1749checksum = "d751e9e49156b02b44f9c1815bcb94b984cdcc4396ecc32521c739452808b134"

2497checksum = "f28aa4e10384e782774b10e72aca4d93ef7b31aa653095d9d4536b0a3dbc51b6"

17502498dependencies = [

1751 "derive_more-impl",

2499 "arrow",

2500 "arrow-buffer",

2501 "base64 0.22.1",

2502 "blake2 0.10.6",

2503 "blake3",

2504 "chrono",

2505 "chrono-tz",

2506 "datafusion-common",

2507 "datafusion-doc",

2508 "datafusion-execution",

2509 "datafusion-expr",

2510 "datafusion-expr-common",

2511 "datafusion-macros",

2512 "hex",

2513 "itertools 0.14.0",

2514 "log 0.4.33",

2515 "md-5 0.10.6",

2516 "memchr",

2517 "num-traits",

2518 "rand 0.9.5",

2519 "regex",

2520 "sha2 0.10.9",

2521 "unicode-segmentation",

2522 "uuid",

17522523]

17532524

17542525[[package]]

1755name = "derive_more-impl"

1756version = "2.1.1"

2526name = "datafusion-functions-aggregate"

2527version = "53.1.0"

17572528source = "registry+https://github.com/rust-lang/crates.io-index"

1758checksum = "799a97264921d8623a957f6c3b9011f3b5492f557bbb7a5a19b7fa6d06ba8dcb"

2529checksum = "00aa6217e56098ba84e0a338176fe52f0a84cca398021512c6c8c5eff806d0ad"

17592530dependencies = [

1760 "proc-macro2",

1761 "quote",

1762 "rustc_version",

1763 "syn 2.0.119",

1764 "unicode-xid",

2531 "ahash 0.8.12",

2532 "arrow",

2533 "datafusion-common",

2534 "datafusion-doc",

2535 "datafusion-execution",

2536 "datafusion-expr",

2537 "datafusion-functions-aggregate-common",

2538 "datafusion-macros",

2539 "datafusion-physical-expr",

2540 "datafusion-physical-expr-common",

2541 "half",

2542 "log 0.4.33",

2543 "num-traits",

2544 "paste",

17652545]

17662546

17672547[[package]]

1768name = "des"

1769version = "0.9.0"

2548name = "datafusion-functions-aggregate-common"

2549version = "53.1.0"

17702550source = "registry+https://github.com/rust-lang/crates.io-index"

1771checksum = "916a94e407b54f9034d71dd748234cd1e516ced6284009906ae246f177eafe5a"

2551checksum = "b511250349407db7c43832ab2de63f5557b19a20dfd236b39ca2c04468b50d47"

17722552dependencies = [

1773 "cipher 0.5.2",

2553 "ahash 0.8.12",

2554 "arrow",

2555 "datafusion-common",

2556 "datafusion-expr-common",

2557 "datafusion-physical-expr-common",

17742558]

17752559

17762560[[package]]

1777name = "digest"

1778version = "0.10.7"

2561name = "datafusion-functions-nested"

2562version = "53.1.0"

17792563source = "registry+https://github.com/rust-lang/crates.io-index"

1780checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"

2564checksum = "ef13a858e20d50f0a9bb5e96e7ac82b4e7597f247515bccca4fdd2992df0212a"

17812565dependencies = [

1782 "block-buffer 0.10.4",

1783 "const-oid 0.9.6",

1784 "crypto-common 0.1.6",

1785 "subtle",

2566 "arrow",

2567 "arrow-ord",

2568 "datafusion-common",

2569 "datafusion-doc",

2570 "datafusion-execution",

2571 "datafusion-expr",

2572 "datafusion-expr-common",

2573 "datafusion-functions",

2574 "datafusion-functions-aggregate",

2575 "datafusion-functions-aggregate-common",

2576 "datafusion-macros",

2577 "datafusion-physical-expr-common",

2578 "hashbrown 0.16.1",

2579 "itertools 0.14.0",

2580 "itoa",

2581 "log 0.4.33",

2582 "paste",

17862583]

17872584

17882585[[package]]

1789name = "digest"

1790version = "0.11.3"

2586name = "datafusion-functions-table"

2587version = "53.1.0"

17912588source = "registry+https://github.com/rust-lang/crates.io-index"

1792checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2"

2589checksum = "72b40d3f5bbb3905f9ccb1ce9485a9595c77b69758a7c24d3ba79e334ff51e7e"

17932590dependencies = [

1794 "block-buffer 0.12.1",

1795 "const-oid 0.10.2",

1796 "crypto-common 0.2.2",

1797 "ctutils",

2591 "arrow",

2592 "async-trait",

2593 "datafusion-catalog",

2594 "datafusion-common",

2595 "datafusion-expr",

2596 "datafusion-physical-plan",

2597 "parking_lot",

2598 "paste",

17982599]

17992600

18002601[[package]]

1801name = "dirs"

1802version = "5.0.1"

2602name = "datafusion-functions-window"

2603version = "53.1.0"

18032604source = "registry+https://github.com/rust-lang/crates.io-index"

1804checksum = "44c45a9d03d6676652bcb5e724c7e988de1acad23a711b5217ab9cbecbec2225"

2605checksum = "d4e88ec9d57c9b685d02f58bfee7be62d72610430ddcedb82a08e5d9925dbfb6"

18052606dependencies = [

1806 "dirs-sys",

2607 "arrow",

2608 "datafusion-common",

2609 "datafusion-doc",

2610 "datafusion-expr",

2611 "datafusion-functions-window-common",

2612 "datafusion-macros",

2613 "datafusion-physical-expr",

2614 "datafusion-physical-expr-common",

2615 "log 0.4.33",

2616 "paste",

18072617]

18082618

18092619[[package]]

1810name = "dirs-sys"

1811version = "0.4.1"

2620name = "datafusion-functions-window-common"

2621version = "53.1.0"

18122622source = "registry+https://github.com/rust-lang/crates.io-index"

1813checksum = "520f05a5cbd335fae5a99ff7a6ab8627577660ee5cfd6a94a6a929b52ff0321c"

2623checksum = "8307bb93519b1a91913723a1130cfafeee3f72200d870d88e91a6fc5470ede5c"

18142624dependencies = [

1815 "libc",

1816 "option-ext",

1817 "redox_users",

1818 "windows-sys 0.48.0",

2625 "datafusion-common",

2626 "datafusion-physical-expr-common",

18192627]

18202628

18212629[[package]]

1822name = "displaydoc"

1823version = "0.2.7"

2630name = "datafusion-macros"

2631version = "53.1.0"

18242632source = "registry+https://github.com/rust-lang/crates.io-index"

1825checksum = "c6232dd377dcc64799954cbd3a9bb882e9cdc1308ccd87b1c098f1fb2eaf82a8"

2633checksum = "2e367e6a71051d0ebdd29b2f85d12059b38b1d1f172c6906e80016da662226bd"

18262634dependencies = [

1827 "proc-macro2",

2635 "datafusion-doc",

18282636 "quote",

1829 "syn 3.0.3",

2637 "syn 2.0.119",

18302638]

18312639

18322640[[package]]

1833name = "dlv-list"

1834version = "0.3.0"

2641name = "datafusion-optimizer"

2642version = "53.1.0"

18352643source = "registry+https://github.com/rust-lang/crates.io-index"

1836checksum = "0688c2a7f92e427f44895cd63841bff7b29f8d7a1648b9e7e07a4a365b2e1257"

2644checksum = "e929015451a67f77d9d8b727b2bf3a40c4445fdef6cdc53281d7d97c76888ace"

2645dependencies = [

2646 "arrow",

2647 "chrono",

2648 "datafusion-common",

2649 "datafusion-expr",

2650 "datafusion-expr-common",

2651 "datafusion-physical-expr",

2652 "indexmap 2.14.0",

2653 "itertools 0.14.0",

2654 "log 0.4.33",

2655 "regex",

2656 "regex-syntax",

2657]

18372658

18382659[[package]]

1839name = "dotenvy"

1840version = "0.15.7"

2660name = "datafusion-physical-expr"

2661version = "53.1.0"

18412662source = "registry+https://github.com/rust-lang/crates.io-index"

1842checksum = "1aaf95b3e5c8f23aa320147307562d361db0ae0d51242340f558153b4eb2439b"

2663checksum = "4b1e68aba7a4b350401cfdf25a3d6f989ad898a7410164afe9ca52080244cb59"

2664dependencies = [

2665 "ahash 0.8.12",

2666 "arrow",

2667 "datafusion-common",

2668 "datafusion-expr",

2669 "datafusion-expr-common",

2670 "datafusion-functions-aggregate-common",

2671 "datafusion-physical-expr-common",

2672 "half",

2673 "hashbrown 0.16.1",

2674 "indexmap 2.14.0",

2675 "itertools 0.14.0",

2676 "parking_lot",

2677 "paste",

2678 "petgraph",

2679 "tokio",

2680]

18432681

18442682[[package]]

1845name = "dunce"

1846version = "1.0.5"

2683name = "datafusion-physical-expr-adapter"

2684version = "53.1.0"

18472685source = "registry+https://github.com/rust-lang/crates.io-index"

1848checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813"

2686checksum = "ea22315f33cf2e0adc104e8ec42e285f6ed93998d565c65e82fec6a9ee9f9db4"

2687dependencies = [

2688 "arrow",

2689 "datafusion-common",

2690 "datafusion-expr",

2691 "datafusion-functions",

2692 "datafusion-physical-expr",

2693 "datafusion-physical-expr-common",

2694 "itertools 0.14.0",

2695]

18492696

18502697[[package]]

1851name = "ecdsa"

1852version = "0.16.9"

2698name = "datafusion-physical-expr-common"

2699version = "53.1.0"

18532700source = "registry+https://github.com/rust-lang/crates.io-index"

1854checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca"

2701checksum = "b04b45ea8ad3ac2d78f2ea2a76053e06591c9629c7a603eda16c10649ecf4362"

18552702dependencies = [

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",

2703 "ahash 0.8.12",

2704 "arrow",

2705 "chrono",

2706 "datafusion-common",

2707 "datafusion-expr-common",

2708 "hashbrown 0.16.1",

2709 "indexmap 2.14.0",

2710 "itertools 0.14.0",

2711 "parking_lot",

18622712]

18632713

18642714[[package]]

1865name = "ecdsa"

1866version = "0.17.0"

2715name = "datafusion-physical-optimizer"

2716version = "53.1.0"

18672717source = "registry+https://github.com/rust-lang/crates.io-index"

1868checksum = "c0681a4fc24c767085329728d8dfba959af91228aa4610cca4f8ce317ba46ae0"

2718checksum = "7cb13397809a425918f608dfe8653f332015a3e330004ab191b4404187238b95"

18692719dependencies = [

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",

2720 "arrow",

2721 "datafusion-common",

2722 "datafusion-execution",

2723 "datafusion-expr",

2724 "datafusion-expr-common",

2725 "datafusion-physical-expr",

2726 "datafusion-physical-expr-common",

2727 "datafusion-physical-plan",

2728 "datafusion-pruning",

2729 "itertools 0.14.0",

18772730]

18782731

18792732[[package]]

1880name = "ed25519"

1881version = "3.0.0"

2733name = "datafusion-physical-plan"

2734version = "53.1.0"

18822735source = "registry+https://github.com/rust-lang/crates.io-index"

1883checksum = "29fcf32e6c73d1079f83ab4d782de2d81620346a5f38c6237a86a22f8368980a"

2736checksum = "5edc023675791af9d5fb4cc4c24abf5f7bd3bd4dcf9e5bd90ea1eff6976dcc79"

18842737dependencies = [

1885 "pkcs8 0.11.0",

1886 "signature 3.0.0",

2738 "ahash 0.8.12",

2739 "arrow",

2740 "arrow-ord",

2741 "arrow-schema",

2742 "async-trait",

2743 "datafusion-common",

2744 "datafusion-common-runtime",

2745 "datafusion-execution",

2746 "datafusion-expr",

2747 "datafusion-functions",

2748 "datafusion-functions-aggregate-common",

2749 "datafusion-functions-window-common",

2750 "datafusion-physical-expr",

2751 "datafusion-physical-expr-common",

2752 "futures",

2753 "half",

2754 "hashbrown 0.16.1",

2755 "indexmap 2.14.0",

2756 "itertools 0.14.0",

2757 "log 0.4.33",

2758 "num-traits",

2759 "parking_lot",

2760 "pin-project-lite",

2761 "tokio",

18872762]

18882763

18892764[[package]]

1890name = "ed25519-dalek"

1891version = "3.0.0"

2765name = "datafusion-pruning"

2766version = "53.1.0"

18922767source = "registry+https://github.com/rust-lang/crates.io-index"

1893checksum = "6ebaa1a2bf1290ab3bfe5a7b771d050ebffab2711c19a81691c683a5144a25de"

2768checksum = "ac8c76860e355616555081cab5968cec1af7a80701ff374510860bcd567e365a"

18942769dependencies = [

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",

2770 "arrow",

2771 "datafusion-common",

2772 "datafusion-datasource",

2773 "datafusion-expr-common",

2774 "datafusion-physical-expr",

2775 "datafusion-physical-expr-common",

2776 "datafusion-physical-plan",

2777 "itertools 0.14.0",

2778 "log 0.4.33",

19032779]

19042780

19052781[[package]]

1906name = "either"

1907version = "1.17.0"

2782name = "datafusion-session"

2783version = "53.1.0"

19082784source = "registry+https://github.com/rust-lang/crates.io-index"

1909checksum = "9e5e8f6c15a24b9a3ee5efec809ccd006d3b30e8b3bb63c39af737c7f87daa1d"

2785checksum = "5412111aa48e2424ba926112e192f7a6b7e4ccb450145d25ce5ede9f19dc491e"

19102786dependencies = [

1911 "serde",

2787 "async-trait",

2788 "datafusion-common",

2789 "datafusion-execution",

2790 "datafusion-expr",

2791 "datafusion-physical-plan",

2792 "parking_lot",

19122793]

19132794

19142795[[package]]

1915name = "elliptic-curve"

1916version = "0.13.8"

2796name = "datafusion-sql"

2797version = "53.1.0"

19172798source = "registry+https://github.com/rust-lang/crates.io-index"

1918checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47"

2799checksum = "fa0d133ddf8b9b3b872acac900157f783e7b879fe9a6bccf389abebbfac45ec1"

19192800dependencies = [

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",

2801 "arrow",

2802 "bigdecimal",

2803 "chrono",

2804 "datafusion-common",

2805 "datafusion-expr",

2806 "datafusion-functions-nested",

2807 "indexmap 2.14.0",

2808 "log 0.4.33",

2809 "regex",

2810 "sqlparser",

19312811]

19322812

19332813[[package]]

1934name = "elliptic-curve"

1935version = "0.14.1"

2814name = "deepsize"

2815version = "0.2.0"

19362816source = "registry+https://github.com/rust-lang/crates.io-index"

1937checksum = "9d65aa39b3a5c1c9c1b745c9a019234bb7a21b77abcb4f4d266d706e2d577d65"

2817checksum = "1cdb987ec36f6bf7bfbea3f928b75590b736fc42af8e54d97592481351b2b96c"

19382818dependencies = [

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",

2819 "deepsize_derive",

19532820]

19542821

19552822[[package]]

1956name = "email"

1957version = "1.0.0"

2823name = "deepsize_derive"

2824version = "0.1.2"

2825source = "registry+https://github.com/rust-lang/crates.io-index"

2826checksum = "990101d41f3bc8c1a45641024377ee284ecc338e5ecf3ea0f0e236d897c72796"

19582827dependencies = [

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",

2828 "proc-macro2",

2829 "quote",

2830 "syn 1.0.109",

19742831]

19752832

19762833[[package]]

1977name = "email-encoding"

1978version = "0.4.2"

2834name = "defmt"

2835version = "1.1.1"

19792836source = "registry+https://github.com/rust-lang/crates.io-index"

1980checksum = "420b9da095f052ea597503e39073b5b3c522f7db933fbac202d91d24492693fd"

2837checksum = "e2953bfe4f93bbd20cc71198842756f77d161884c99ebbabc41d80231ded88d1"

19812838dependencies = [

1982 "base64 0.23.1",

1983 "memchr",

2839 "bitflags 1.3.2",

2840 "defmt-macros",

19842841]

19852842

19862843[[package]]

1987name = "email_address"

1988version = "0.2.9"

2844name = "defmt-macros"

2845version = "1.1.1"

19892846source = "registry+https://github.com/rust-lang/crates.io-index"

1990checksum = "e079f19b08ca6239f47f8ba8509c11cf3ea30095831f7fed61441475edd8c449"

2847checksum = "bad9c72e7ca2137e0dc3813245a0d282fd6daad32fd800af018306a9169b5fe8"

2848dependencies = [

2849 "defmt-parser",

2850 "proc-macro2",

2851 "quote",

2852 "syn 2.0.119",

2853]

19912854

19922855[[package]]

1993name = "encoding_rs"

1994version = "0.8.35"

2856name = "defmt-parser"

2857version = "1.0.0"

19952858source = "registry+https://github.com/rust-lang/crates.io-index"

1996checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3"

2859checksum = "10d60334b3b2e7c9d91ef8150abfb6fa4c1c39ebbcf4a81c2e346aad939fee3e"

19972860dependencies = [

1998 "cfg-if",

2861 "thiserror 2.0.20",

19992862]

20002863

20012864[[package]]

2002name = "enum_dispatch"

2003version = "0.3.13"

2865name = "delegate"

2866version = "0.13.5"

20042867source = "registry+https://github.com/rust-lang/crates.io-index"

2005checksum = "aa18ce2bc66555b3218614519ac839ddb759a7d6720732f979ef8d13be147ecd"

2868checksum = "780eb241654bf097afb00fc5f054a09b687dad862e485fdcf8399bb056565370"

20062869dependencies = [

2007 "once_cell",

20082870 "proc-macro2",

20092871 "quote",

20102872 "syn 2.0.119",

20112873]

20122874

20132875[[package]]

2014name = "equivalent"

2015version = "1.0.2"

2876name = "der"

2877version = "0.7.10"

20162878source = "registry+https://github.com/rust-lang/crates.io-index"

2017checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"

2879checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb"

2880dependencies = [

2881 "const-oid 0.9.6",

2882 "zeroize",

2883]

20182884

20192885[[package]]

2020name = "errno"

2021version = "0.3.14"

2886name = "der"

2887version = "0.8.1"

20222888source = "registry+https://github.com/rust-lang/crates.io-index"

2023checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"

2889checksum = "a69dedd701da44b0536442edf09c81a64b0ab97a7a4a5e3d1971f00027cbc63d"

20242890dependencies = [

2025 "libc",

2026 "windows-sys 0.61.2",

2891 "const-oid 0.10.2",

2892 "pem-rfc7468 1.0.0",

2893 "zeroize",

20272894]

20282895

20292896[[package]]

2030name = "etcetera"

2031version = "0.11.0"

2897name = "deranged"

2898version = "0.5.8"

20322899source = "registry+https://github.com/rust-lang/crates.io-index"

2033checksum = "de48cc4d1c1d97a20fd819def54b890cadde72ed3ad0c614822a0a433361be96"

2900checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"

20342901dependencies = [

2035 "cfg-if",

2036 "windows-sys 0.61.2",

2902 "serde_core",

20372903]

20382904

20392905[[package]]

2040name = "event-listener"

2041version = "5.4.2"

2906name = "derive-where"

2907version = "1.6.1"

20422908source = "registry+https://github.com/rust-lang/crates.io-index"

2043checksum = "5a23add41df1562121a9393cb065eab5146a1242410f23a644851e90cfd669d2"

2909checksum = "d08b3a0bcc0d079199cd476b2cae8435016ec11d1c0986c6901c5ac223041534"

20442910dependencies = [

2045 "parking",

2046 "pin-project-lite",

2911 "proc-macro2",

2912 "quote",

2913 "syn 2.0.119",

20472914]

20482915

20492916[[package]]

2050name = "event-listener-strategy"

2051version = "0.5.4"

2917name = "derive_arbitrary"

2918version = "1.4.2"

20522919source = "registry+https://github.com/rust-lang/crates.io-index"

2053checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"

2920checksum = "1e567bd82dcff979e4b03460c307b3cdc9e96fde3d73bed1496d2bc75d9dd62a"

20542921dependencies = [

2055 "event-listener",

2056 "pin-project-lite",

2922 "proc-macro2",

2923 "quote",

2924 "syn 2.0.119",

20572925]

20582926

20592927[[package]]

2060name = "export"

2061version = "1.0.0"

2928name = "derive_builder"

2929version = "0.20.2"

2930source = "registry+https://github.com/rust-lang/crates.io-index"

2931checksum = "507dfb09ea8b7fa618fcf76e953f4f5e192547945816d5358edffe39f6f94947"

20622932dependencies = [

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",

2933 "derive_builder_macro",

20792934]

20802935

20812936[[package]]

2082name = "fast_chemail"

2083version = "0.9.6"

2937name = "derive_builder_core"

2938version = "0.20.2"

20842939source = "registry+https://github.com/rust-lang/crates.io-index"

2085checksum = "495a39d30d624c2caabe6312bfead73e7717692b44e0b32df168c275a2e8e9e4"

2940checksum = "2d5bcf7b024d6835cfb3d473887cd966994907effbe9227e8c8219824d06c4e8"

20862941dependencies = [

2087 "ascii_utils",

2942 "darling 0.20.11",

2943 "proc-macro2",

2944 "quote",

2945 "syn 2.0.119",

20882946]

20892947

20902948[[package]]

2091name = "fastant"

2092version = "0.1.11"

2949name = "derive_builder_macro"

2950version = "0.20.2"

20932951source = "registry+https://github.com/rust-lang/crates.io-index"

2094checksum = "2e825441bfb2d831c47c97d05821552db8832479f44c571b97fededbf0099c07"

2952checksum = "ab63b0e2bf4d5928aff72e83a7dace85d7bba5fe12dcc3c5a572d78caffd3f3c"

20952953dependencies = [

2096 "small_ctor",

2097 "web-time",

2954 "derive_builder_core",

2955 "syn 2.0.119",

20982956]

20992957

21002958[[package]]

2101name = "fastbloom-rs"

2102version = "0.5.10"

2959name = "derive_more"

2960version = "2.1.1"

21032961source = "registry+https://github.com/rust-lang/crates.io-index"

2104checksum = "1cedd8cf9a34b304cfa127370e66b51f85c412cf1a9cc15ec39fc1fe2912403a"

2962checksum = "d751e9e49156b02b44f9c1815bcb94b984cdcc4396ecc32521c739452808b134"

21052963dependencies = [

2106 "cuckoofilter",

2107 "fastmurmur3",

2108 "xorfilter-rs",

2109 "xxhash-rust",

2964 "derive_more-impl",

21102965]

21112966

21122967[[package]]

2113name = "faster-hex"

2114version = "0.10.0"

2968name = "derive_more-impl"

2969version = "2.1.1"

21152970source = "registry+https://github.com/rust-lang/crates.io-index"

2116checksum = "7223ae2d2f179b803433d9c830478527e92b8117eab39460edae7f1614d9fb73"

2971checksum = "799a97264921d8623a957f6c3b9011f3b5492f557bbb7a5a19b7fa6d06ba8dcb"

21172972dependencies = [

2118 "heapless",

2119 "serde",

2973 "proc-macro2",

2974 "quote",

2975 "rustc_version",

2976 "syn 2.0.119",

2977 "unicode-xid",

21202978]

21212979

21222980[[package]]

2123name = "fastmurmur3"

2124version = "0.2.0"

2981name = "des"

2982version = "0.9.0"

21252983source = "registry+https://github.com/rust-lang/crates.io-index"

2126checksum = "2d7e9bc68be4cdabbb8938140b01a8b5bc1191937f2c7e7ecc2fcebbe2d749df"

2984checksum = "916a94e407b54f9034d71dd748234cd1e516ced6284009906ae246f177eafe5a"

2985dependencies = [

2986 "cipher 0.5.2",

2987]

21272988

21282989[[package]]

2129name = "fastrand"

2130version = "2.5.0"

2990name = "digest"

2991version = "0.10.7"

21312992source = "registry+https://github.com/rust-lang/crates.io-index"

2132checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223"

2133

2134[[package]]

2135name = "ff"

2136version = "0.13.1"

2137source = "registry+https://github.com/rust-lang/crates.io-index"

2138checksum = "c0b50bfb653653f9ca9095b427bed08ab8d75a137839d9ad64eb11810d5b6393"

2993checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"

21392994dependencies = [

2140 "rand_core 0.6.4",

2995 "block-buffer 0.10.4",

2996 "const-oid 0.9.6",

2997 "crypto-common 0.1.6",

21412998 "subtle",

21422999]

21433000

21443001[[package]]

2145name = "ff"

2146version = "0.14.0"

3002name = "digest"

3003version = "0.11.3"

21473004source = "registry+https://github.com/rust-lang/crates.io-index"

2148checksum = "a1f686ab92a9fb0eaf188f6c6c87b89490baa6fdb0db4544ba4dc47f7942489f"

3005checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2"

21493006dependencies = [

2150 "rand_core 0.10.1",

2151 "subtle",

3007 "block-buffer 0.12.1",

3008 "const-oid 0.10.2",

3009 "crypto-common 0.2.2",

3010 "ctutils",

21523011]

21533012

21543013[[package]]

2155name = "fiat-crypto"

2156version = "0.3.0"

3014name = "dirs"

3015version = "5.0.1"

21573016source = "registry+https://github.com/rust-lang/crates.io-index"

2158checksum = "64cd1e32ddd350061ae6edb1b082d7c54915b5c672c389143b9a63403a109f24"

3017checksum = "44c45a9d03d6676652bcb5e724c7e988de1acad23a711b5217ab9cbecbec2225"

3018dependencies = [

3019 "dirs-sys 0.4.1",

3020]

21593021

21603022[[package]]

2161name = "figment"

2162version = "0.10.19"

3023name = "dirs"

3024version = "6.0.0"

21633025source = "registry+https://github.com/rust-lang/crates.io-index"

2164checksum = "8cb01cd46b0cf372153850f4c6c272d9cbea2da513e07538405148f95bd789f3"

3026checksum = "c3e8aa94d75141228480295a7d0e7feb620b1a5ad9f12bc40be62411e38cce4e"

21653027dependencies = [

2166 "atomic",

2167 "pear",

2168 "serde",

2169 "toml",

2170 "uncased",

2171 "version_check 0.9.5",

3028 "dirs-sys 0.5.0",

21723029]

21733030

21743031[[package]]

2175name = "filetime"

2176version = "0.2.29"

3032name = "dirs-sys"

3033version = "0.4.1"

21773034source = "registry+https://github.com/rust-lang/crates.io-index"

2178checksum = "5c287a33c7f0a620c38e641e7f60827713987b3c0f26e8ddc9462cc69cf75759"

3035checksum = "520f05a5cbd335fae5a99ff7a6ab8627577660ee5cfd6a94a6a929b52ff0321c"

21793036dependencies = [

2180 "cfg-if",

21813037 "libc",

3038 "option-ext",

3039 "redox_users 0.4.6",

3040 "windows-sys 0.48.0",

21823041]

21833042

21843043[[package]]

2185name = "find-msvc-tools"

2186version = "0.1.11"

3044name = "dirs-sys"

3045version = "0.5.0"

21873046source = "registry+https://github.com/rust-lang/crates.io-index"

2188checksum = "d45db016d36b838f563236e9193d0ee6ce38f3f68b6c94e914b4929c96bbb890"

3047checksum = "e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab"

3048dependencies = [

3049 "libc",

3050 "option-ext",

3051 "redox_users 0.5.2",

3052 "windows-sys 0.61.2",

3053]

21893054

21903055[[package]]

2191name = "fixed_decimal"

2192version = "0.7.2"

3056name = "displaydoc"

3057version = "0.2.7"

21933058source = "registry+https://github.com/rust-lang/crates.io-index"

2194checksum = "79c3c892f121fff406e5dd6b28c1b30096b95111c30701a899d4f2b18da6d1bd"

3059checksum = "c6232dd377dcc64799954cbd3a9bb882e9cdc1308ccd87b1c098f1fb2eaf82a8"

21953060dependencies = [

2196 "displaydoc",

2197 "smallvec",

2198 "writeable",

3061 "proc-macro2",

3062 "quote",

3063 "syn 3.0.3",

21993064]

22003065

22013066[[package]]

2202name = "flate2"

2203version = "1.1.9"

3067name = "dlv-list"

3068version = "0.3.0"

22043069source = "registry+https://github.com/rust-lang/crates.io-index"

2205checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"

2206dependencies = [

2207 "crc32fast",

2208 "miniz_oxide",

2209 "zlib-rs",

2210]

3070checksum = "0688c2a7f92e427f44895cd63841bff7b29f8d7a1648b9e7e07a4a365b2e1257"

22113071

22123072[[package]]

2213name = "flume"

2214version = "0.12.0"

3073name = "dotenvy"

3074version = "0.15.7"

22153075source = "registry+https://github.com/rust-lang/crates.io-index"

2216checksum = "5e139bc46ca777eb5efaf62df0ab8cc5fd400866427e56c68b22e414e53bd3be"

2217dependencies = [

2218 "futures-core",

2219 "futures-sink",

2220 "spin",

2221]

3076checksum = "1aaf95b3e5c8f23aa320147307562d361db0ae0d51242340f558153b4eb2439b"

22223077

22233078[[package]]

2224name = "fnv"

2225version = "1.0.7"

3079name = "dunce"

3080version = "1.0.5"

22263081source = "registry+https://github.com/rust-lang/crates.io-index"

2227checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"

3082checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813"

22283083

22293084[[package]]

2230name = "foldhash"

2231version = "0.2.0"

3085name = "dyn-clone"

3086version = "1.0.20"

22323087source = "registry+https://github.com/rust-lang/crates.io-index"

2233checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"

3088checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555"

22343089

22353090[[package]]

2236name = "foreign-types"

2237version = "0.3.2"

3091name = "ecdsa"

3092version = "0.16.9"

22383093source = "registry+https://github.com/rust-lang/crates.io-index"

2239checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"

3094checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca"

22403095dependencies = [

2241 "foreign-types-shared",

3096 "der 0.7.10",

3097 "digest 0.10.7",

3098 "elliptic-curve 0.13.8",

3099 "rfc6979 0.4.0",

3100 "signature 2.2.0",

3101 "spki 0.7.3",

22423102]

22433103

22443104[[package]]

2245name = "foreign-types-shared"

2246version = "0.1.1"

3105name = "ecdsa"

3106version = "0.17.0"

22473107source = "registry+https://github.com/rust-lang/crates.io-index"

2248checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"

3108checksum = "c0681a4fc24c767085329728d8dfba959af91228aa4610cca4f8ce317ba46ae0"

3109dependencies = [

3110 "der 0.8.1",

3111 "digest 0.11.3",

3112 "elliptic-curve 0.14.1",

3113 "rfc6979 0.6.0",

3114 "signature 3.0.0",

3115 "spki 0.8.0",

3116 "zeroize",

3117]

22493118

22503119[[package]]

2251name = "form_urlencoded"

2252version = "1.2.2"

3120name = "ed25519"

3121version = "3.0.0"

22533122source = "registry+https://github.com/rust-lang/crates.io-index"

2254checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"

3123checksum = "29fcf32e6c73d1079f83ab4d782de2d81620346a5f38c6237a86a22f8368980a"

22553124dependencies = [

2256 "percent-encoding 2.3.2",

3125 "pkcs8 0.11.0",

3126 "signature 3.0.0",

22573127]

22583128

22593129[[package]]

2260name = "forwarded-header-value"

2261version = "0.1.1"

3130name = "ed25519-dalek"

3131version = "3.0.0"

22623132source = "registry+https://github.com/rust-lang/crates.io-index"

2263checksum = "8835f84f38484cc86f110a805655697908257fb9a7af005234060891557198e9"

3133checksum = "6ebaa1a2bf1290ab3bfe5a7b771d050ebffab2711c19a81691c683a5144a25de"

22643134dependencies = [

2265 "nonempty 0.7.0",

2266 "thiserror 1.0.69",

3135 "curve25519-dalek",

3136 "ed25519",

3137 "rand_core 0.10.1",

3138 "serde",

3139 "sha2 0.11.0",

3140 "signature 3.0.0",

3141 "subtle",

3142 "zeroize",

22673143]

22683144

22693145[[package]]

2270name = "foyer"

2271version = "0.22.3"

3146name = "either"

3147version = "1.17.0"

22723148source = "registry+https://github.com/rust-lang/crates.io-index"

2273checksum = "3b0abc0b87814989efa711f9becd9f26969820e2d3905db27d10969c4bd45890"

3149checksum = "9e5e8f6c15a24b9a3ee5efec809ccd006d3b30e8b3bb63c39af737c7f87daa1d"

22743150dependencies = [

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",

22853151 "serde",

2286 "tracing",

22873152]

22883153

22893154[[package]]

2290name = "foyer-common"

2291version = "0.22.3"

3155name = "elliptic-curve"

3156version = "0.13.8"

22923157source = "registry+https://github.com/rust-lang/crates.io-index"

2293checksum = "a3db80d5dece93adb7ad709c84578794724a9cba342a7e566c3551c7ec626789"

3158checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47"

22943159dependencies = [

2295 "anyhow",

2296 "bytes",

2297 "cfg-if",

2298 "foyer-tokio",

2299 "mixtrics",

2300 "parking_lot",

2301 "pin-project",

2302 "twox-hash",

3160 "base16ct 0.2.0",

3161 "crypto-bigint 0.5.5",

3162 "digest 0.10.7",

3163 "ff 0.13.1",

3164 "generic-array 0.14.9",

3165 "group 0.13.0",

3166 "pkcs8 0.10.2",

3167 "rand_core 0.6.4",

3168 "sec1 0.7.3",

3169 "subtle",

3170 "zeroize",

23033171]

23043172

23053173[[package]]

2306name = "foyer-intrusive-collections"

2307version = "0.10.0-dev"

3174name = "elliptic-curve"

3175version = "0.14.1"

23083176source = "registry+https://github.com/rust-lang/crates.io-index"

2309checksum = "6e4fee46bea69e0596130e3210e65d3424e0ac1e6df3bde6636304bdf1ca4a3b"

3177checksum = "9d65aa39b3a5c1c9c1b745c9a019234bb7a21b77abcb4f4d266d706e2d577d65"

23103178dependencies = [

2311 "memoffset",

3179 "base16ct 1.0.0",

3180 "crypto-bigint 0.7.5",

3181 "crypto-common 0.2.2",

3182 "digest 0.11.3",

3183 "ff 0.14.0",

3184 "group 0.14.0",

3185 "hkdf",

3186 "hybrid-array",

3187 "pem-rfc7468 1.0.0",

3188 "pkcs8 0.11.0",

3189 "rand_core 0.10.1",

3190 "sec1 0.8.1",

3191 "subtle",

3192 "zeroize",

23123193]

23133194

23143195[[package]]

2315name = "foyer-memory"

2316version = "0.22.3"

2317source = "registry+https://github.com/rust-lang/crates.io-index"

2318checksum = "db907f40a527ca2aa2f40a5f68b32ea58aa70f050cd233518e9ffd402cfba6ce"

3196name = "email"

3197version = "1.0.0"

23193198dependencies = [

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",

3199 "async-trait",

3200 "base64 0.23.1",

3201 "bytes",

3202 "config",

3203 "futures",

3204 "lettre",

3205 "maud",

3206 "redis",

23353207 "serde",

3208 "serde_json",

3209 "time 0.3.55",

3210 "tokio",

3211 "tokio-util",

23363212 "tracing",

3213 "uuid",

23373214]

23383215

23393216[[package]]

2340name = "foyer-storage"

2341version = "0.22.3"

3217name = "email-encoding"

3218version = "0.4.2"

23423219source = "registry+https://github.com/rust-lang/crates.io-index"

2343checksum = "1983f1db3d0710e9c9d5fc116d9202dccd41a2d1e032572224f1aff5520aa958"

3220checksum = "420b9da095f052ea597503e39073b5b3c522f7db933fbac202d91d24492693fd"

23443221dependencies = [

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",

3222 "base64 0.23.1",

3223 "memchr",

23693224]

23703225

23713226[[package]]

2372name = "foyer-tokio"

2373version = "0.22.3"

2374source = "registry+https://github.com/rust-lang/crates.io-index"

2375checksum = "f6577b05a7ffad0db555aedf00bfe52af818220fc4c1c3a7a12520896fc38627"

3227name = "email_address"

3228version = "0.2.9"

3229source = "registry+https://github.com/rust-lang/crates.io-index"

3230checksum = "e079f19b08ca6239f47f8ba8509c11cf3ea30095831f7fed61441475edd8c449"

3231

3232[[package]]

3233name = "encode_unicode"

3234version = "1.0.0"

3235source = "registry+https://github.com/rust-lang/crates.io-index"

3236checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"

3237

3238[[package]]

3239name = "encoding_rs"

3240version = "0.8.35"

3241source = "registry+https://github.com/rust-lang/crates.io-index"

3242checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3"

23763243dependencies = [

2377 "tokio",

3244 "cfg-if",

23783245]

23793246

23803247[[package]]

2381name = "fs4"

2382version = "0.13.1"

3248name = "encoding_rs_io"

3249version = "0.1.8"

23833250source = "registry+https://github.com/rust-lang/crates.io-index"

2384checksum = "8640e34b88f7652208ce9e88b1a37a2ae95227d84abec377ccd3c5cfeb141ed4"

3251checksum = "fba3fe847045ecff794b9c138293a80db914678c453ad63fbf0c6a9eb6e00b22"

23853252dependencies = [

2386 "rustix",

2387 "windows-sys 0.59.0",

3253 "encoding_rs",

23883254]

23893255

23903256[[package]]

2391name = "fs_extra"

2392version = "1.3.0"

3257name = "enum_dispatch"

3258version = "0.3.13"

23933259source = "registry+https://github.com/rust-lang/crates.io-index"

2394checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"

3260checksum = "aa18ce2bc66555b3218614519ac839ddb759a7d6720732f979ef8d13be147ecd"

3261dependencies = [

3262 "once_cell",

3263 "proc-macro2",

3264 "quote",

3265 "syn 2.0.119",

3266]

23953267

23963268[[package]]

2397name = "funty"

2398version = "2.0.0"

3269name = "equator"

3270version = "0.4.2"

23993271source = "registry+https://github.com/rust-lang/crates.io-index"

2400checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"

3272checksum = "4711b213838dfee0117e3be6ac926007d7f433d7bbe33595975d4190cb07e6fc"

3273dependencies = [

3274 "equator-macro",

3275]

24013276

24023277[[package]]

2403name = "futures"

2404version = "0.3.34"

3278name = "equator-macro"

3279version = "0.4.2"

24053280source = "registry+https://github.com/rust-lang/crates.io-index"

2406checksum = "9a31d2a3fbaaeb2af2368bbdd904aa8e812d3c04a1ee10d3171f52d556e5d0a3"

3281checksum = "44f23cf4b44bfce11a86ace86f8a73ffdec849c9fd00a386a53d278bd9e81fb3"

24073282dependencies = [

2408 "futures-channel",

2409 "futures-core",

2410 "futures-executor",

2411 "futures-io",

2412 "futures-sink",

2413 "futures-task",

2414 "futures-util",

3283 "proc-macro2",

3284 "quote",

3285 "syn 2.0.119",

24153286]

24163287

24173288[[package]]

2418name = "futures-channel"

2419version = "0.3.34"

3289name = "equivalent"

3290version = "1.0.2"

3291source = "registry+https://github.com/rust-lang/crates.io-index"

3292checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"

3293

3294[[package]]

3295name = "errno"

3296version = "0.3.14"

24203297source = "registry+https://github.com/rust-lang/crates.io-index"

2421checksum = "b1f9e3d69d39e4862ffed03ed071a76f9a13ba1d9109d355b0f0aa6b15e393c4"

3298checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"

24223299dependencies = [

2423 "futures-core",

2424 "futures-sink",

3300 "libc",

3301 "windows-sys 0.61.2",

24253302]

24263303

24273304[[package]]

2428name = "futures-core"

2429version = "0.3.34"

3305name = "esaxx-rs"

3306version = "0.1.10"

24303307source = "registry+https://github.com/rust-lang/crates.io-index"

2431checksum = "92d699e522242e69e3003b94ecc1f960f3a5e015aa7c5d7486e65ad01dd94f5e"

3308checksum = "d817e038c30374a4bcb22f94d0a8a0e216958d4c3dcde369b1439fec4bdda6e6"

24323309

24333310[[package]]

2434name = "futures-executor"

2435version = "0.3.34"

3311name = "etcetera"

3312version = "0.11.0"

24363313source = "registry+https://github.com/rust-lang/crates.io-index"

2437checksum = "031b47cf1a3c6cc8bc2fc76cd437f521619387907d469316e7c0bc278f1f5432"

3314checksum = "de48cc4d1c1d97a20fd819def54b890cadde72ed3ad0c614822a0a433361be96"

24383315dependencies = [

2439 "futures-core",

2440 "futures-task",

2441 "futures-util",

3316 "cfg-if",

3317 "windows-sys 0.61.2",

24423318]

24433319

24443320[[package]]

2445name = "futures-intrusive"

2446version = "0.5.0"

3321name = "ethnum"

3322version = "1.5.3"

3323source = "registry+https://github.com/rust-lang/crates.io-index"

3324checksum = "40404c3f5f511ec4da6fe866ddf6a717c309fdbb69fbbad7b0f3edab8f2e835f"

3325

3326[[package]]

3327name = "event-listener"

3328version = "5.4.2"

24473329source = "registry+https://github.com/rust-lang/crates.io-index"

2448checksum = "1d930c203dd0b6ff06e0201a4a2fe9149b43c684fd4420555b26d21b1a02956f"

3330checksum = "5a23add41df1562121a9393cb065eab5146a1242410f23a644851e90cfd669d2"

24493331dependencies = [

2450 "futures-core",

2451 "lock_api",

2452 "parking_lot",

3332 "parking",

3333 "pin-project-lite",

24533334]

24543335

24553336[[package]]

2456name = "futures-io"

2457version = "0.3.34"

3337name = "event-listener-strategy"

3338version = "0.5.4"

24583339source = "registry+https://github.com/rust-lang/crates.io-index"

2459checksum = "53c0fa8157de1303bfffdaa1cc2a673bfffb60102f76b0ef4441659124373fed"

3340checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"

3341dependencies = [

3342 "event-listener",

3343 "pin-project-lite",

3344]

24603345

24613346[[package]]

2462name = "futures-lite"

2463version = "2.6.1"

3347name = "eventsource-stream"

3348version = "0.2.3"

24643349source = "registry+https://github.com/rust-lang/crates.io-index"

2465checksum = "f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad"

3350checksum = "74fef4569247a5f429d9156b9d0a2599914385dd189c539334c625d8099d90ab"

24663351dependencies = [

24673352 "futures-core",

3353 "nom 7.1.3",

24683354 "pin-project-lite",

24693355]

24703356

24713357[[package]]

2472name = "futures-macro"

2473version = "0.3.34"

2474source = "registry+https://github.com/rust-lang/crates.io-index"

2475checksum = "9fb9654ba8355388abeb8dcb4fc62f511300867002afc858860463bdd9fe0c44"

3358name = "export"

3359version = "1.0.0"

24763360dependencies = [

2477 "proc-macro2",

2478 "quote",

2479 "syn 3.0.3",

3361 "axum",

3362 "bytes",

3363 "config",

3364 "email",

3365 "http-body-util",

3366 "rand 0.8.7",

3367 "redis",

3368 "sea-orm",

3369 "serde",

3370 "serde_json",

3371 "storage",

3372 "tokio",

3373 "tower",

3374 "tracing",

3375 "utoipa",

3376 "uuid",

24803377]

24813378

24823379[[package]]

2483name = "futures-sink"

2484version = "0.3.34"

3380name = "exr"

3381version = "1.74.2"

24853382source = "registry+https://github.com/rust-lang/crates.io-index"

2486checksum = "1944426bf7d03f1d14f708785e4b33efd750b36d48a157b836b3efc15ede8e1d"

3383checksum = "711fe42c9964295e01ee3fba3f9fe0e1d24b98886950d68efe81b1c76e21adf3"

3384dependencies = [

3385 "bit_field",

3386 "half",

3387 "lebe",

3388 "miniz_oxide",

3389 "num-complex",

3390 "pulp",

3391 "rayon-core",

3392 "smallvec",

3393 "zune-inflate",

3394]

24873395

24883396[[package]]

2489name = "futures-task"

2490version = "0.3.34"

3397name = "fast-float2"

3398version = "0.2.4"

24913399source = "registry+https://github.com/rust-lang/crates.io-index"

2492checksum = "cd417de3d1d015fc3bfd2b1ea46dfc7bab72ef86f1cc7cc9c78e728b34a6d1fd"

3400checksum = "c6e8948ce679d00a02a94739ea185595dca7118ed04feb991127e443bd3d761f"

24933401

24943402[[package]]

2495name = "futures-util"

2496version = "0.3.34"

3403name = "fast_chemail"

3404version = "0.9.6"

24973405source = "registry+https://github.com/rust-lang/crates.io-index"

2498checksum = "0d50a92467f8ba5dd6e3ee5d4bd04d73ab2e4e1c44474a0674821dfce14b79bc"

3406checksum = "495a39d30d624c2caabe6312bfead73e7717692b44e0b32df168c275a2e8e9e4"

24993407dependencies = [

2500 "futures-channel",

2501 "futures-core",

2502 "futures-io",

2503 "futures-macro",

2504 "futures-sink",

2505 "futures-task",

2506 "memchr",

2507 "pin-project-lite",

2508 "slab",

3408 "ascii_utils",

25093409]

25103410

25113411[[package]]

2512name = "generic-array"

2513version = "0.14.9"

3412name = "fastant"

3413version = "0.1.11"

25143414source = "registry+https://github.com/rust-lang/crates.io-index"

2515checksum = "4bb6743198531e02858aeaea5398fcc883e71851fcbcb5a2f773e2fb6cb1edf2"

3415checksum = "2e825441bfb2d831c47c97d05821552db8832479f44c571b97fededbf0099c07"

25163416dependencies = [

2517 "typenum",

2518 "version_check 0.9.5",

2519 "zeroize",

3417 "small_ctor",

3418 "web-time",

25203419]

25213420

25223421[[package]]

2523name = "generic-array"

2524version = "1.4.5"

3422name = "fastbloom-rs"

3423version = "0.5.10"

25253424source = "registry+https://github.com/rust-lang/crates.io-index"

2526checksum = "337d46834ee672ab3e48caca2cb0c78cc174fb12b3a68d0d88f99a0519a5e36e"

3425checksum = "1cedd8cf9a34b304cfa127370e66b51f85c412cf1a9cc15ec39fc1fe2912403a"

25273426dependencies = [

2528 "generic-array 0.14.9",

2529 "rustversion",

2530 "typenum",

3427 "cuckoofilter",

3428 "fastmurmur3",

3429 "xorfilter-rs",

3430 "xxhash-rust",

25313431]

25323432

25333433[[package]]

2534name = "getrandom"

2535version = "0.1.16"

3434name = "fastembed"

3435version = "4.9.1"

25363436source = "registry+https://github.com/rust-lang/crates.io-index"

2537checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce"

3437checksum = "04c269a76bfc6cea69553b7d040acb16c793119cebd97c756d21e08d0f075ff8"

25383438dependencies = [

2539 "cfg-if",

2540 "libc",

2541 "wasi 0.9.0+wasi-snapshot-preview1",

3439 "anyhow",

3440 "hf-hub",

3441 "image",

3442 "ndarray",

3443 "ort",

3444 "ort-sys",

3445 "rayon",

3446 "serde_json",

3447 "tokenizers",

25423448]

25433449

25443450[[package]]

2545name = "getrandom"

2546version = "0.2.17"

3451name = "faster-hex"

3452version = "0.10.0"

25473453source = "registry+https://github.com/rust-lang/crates.io-index"

2548checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"

3454checksum = "7223ae2d2f179b803433d9c830478527e92b8117eab39460edae7f1614d9fb73"

25493455dependencies = [

2550 "cfg-if",

2551 "js-sys",

2552 "libc",

2553 "wasi 0.11.1+wasi-snapshot-preview1",

2554 "wasm-bindgen",

3456 "heapless",

3457 "serde",

25553458]

25563459

25573460[[package]]

2558name = "getrandom"

2559version = "0.3.4"

3461name = "fastmurmur3"

3462version = "0.2.0"

25603463source = "registry+https://github.com/rust-lang/crates.io-index"

2561checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"

2562dependencies = [

2563 "cfg-if",

2564 "libc",

2565 "r-efi 5.3.0",

2566 "wasip2",

2567]

3464checksum = "2d7e9bc68be4cdabbb8938140b01a8b5bc1191937f2c7e7ecc2fcebbe2d749df"

25683465

25693466[[package]]

2570name = "getrandom"

2571version = "0.4.3"

3467name = "fastrand"

3468version = "2.5.0"

25723469source = "registry+https://github.com/rust-lang/crates.io-index"

2573checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099"

2574dependencies = [

2575 "cfg-if",

2576 "js-sys",

2577 "libc",

2578 "r-efi 6.0.0",

2579 "rand_core 0.10.1",

2580 "wasm-bindgen",

2581]

3470checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223"

25823471

25833472[[package]]

2584name = "ghash"

2585version = "0.5.1"

3473name = "fax"

3474version = "0.2.7"

25863475source = "registry+https://github.com/rust-lang/crates.io-index"

2587checksum = "f0d8a4362ccb29cb0b265253fb0a2728f592895ee6854fd9bc13f2ffda266ff1"

2588dependencies = [

2589 "opaque-debug",

2590 "polyval 0.6.2",

2591]

3476checksum = "caf1079563223d5d59d83c85886a56e586cfd5c1a26292e971a0fa266531ac5a"

25923477

25933478[[package]]

2594name = "ghash"

2595version = "0.6.0"

3479name = "fdeflate"

3480version = "0.3.7"

25963481source = "registry+https://github.com/rust-lang/crates.io-index"

2597checksum = "2eecf2d5dc9b66b732b97707a0210906b1d30523eb773193ab777c0c84b3e8d5"

3482checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c"

25983483dependencies = [

2599 "polyval 0.7.3",

3484 "simd-adler32",

26003485]

26013486

26023487[[package]]

2603name = "git"

2604version = "1.0.0"

3488name = "ff"

3489version = "0.13.1"

3490source = "registry+https://github.com/rust-lang/crates.io-index"

3491checksum = "c0b50bfb653653f9ca9095b427bed08ab8d75a137839d9ad64eb11810d5b6393"

3492dependencies = [

3493 "rand_core 0.6.4",

3494 "subtle",

3495]

3496

3497[[package]]

3498name = "ff"

3499version = "0.14.0"

3500source = "registry+https://github.com/rust-lang/crates.io-index"

3501checksum = "a1f686ab92a9fb0eaf188f6c6c87b89490baa6fdb0db4544ba4dc47f7942489f"

3502dependencies = [

3503 "rand_core 0.10.1",

3504 "subtle",

3505]

3506

3507[[package]]

3508name = "fiat-crypto"

3509version = "0.3.0"

3510source = "registry+https://github.com/rust-lang/crates.io-index"

3511checksum = "64cd1e32ddd350061ae6edb1b082d7c54915b5c672c389143b9a63403a109f24"

3512

3513[[package]]

3514name = "figment"

3515version = "0.10.19"

3516source = "registry+https://github.com/rust-lang/crates.io-index"

3517checksum = "8cb01cd46b0cf372153850f4c6c272d9cbea2da513e07538405148f95bd789f3"

3518dependencies = [

3519 "atomic",

3520 "pear",

3521 "serde",

3522 "toml",

3523 "uncased",

3524 "version_check 0.9.5",

3525]

3526

3527[[package]]

3528name = "filetime"

3529version = "0.2.29"

3530source = "registry+https://github.com/rust-lang/crates.io-index"

3531checksum = "5c287a33c7f0a620c38e641e7f60827713987b3c0f26e8ddc9462cc69cf75759"

3532dependencies = [

3533 "cfg-if",

3534 "libc",

3535]

3536

3537[[package]]

3538name = "find-msvc-tools"

3539version = "0.1.11"

3540source = "registry+https://github.com/rust-lang/crates.io-index"

3541checksum = "d45db016d36b838f563236e9193d0ee6ce38f3f68b6c94e914b4929c96bbb890"

3542

3543[[package]]

3544name = "fixed_decimal"

3545version = "0.7.2"

3546source = "registry+https://github.com/rust-lang/crates.io-index"

3547checksum = "79c3c892f121fff406e5dd6b28c1b30096b95111c30701a899d4f2b18da6d1bd"

3548dependencies = [

3549 "displaydoc",

3550 "smallvec",

3551 "writeable",

3552]

3553

3554[[package]]

3555name = "fixedbitset"

3556version = "0.5.7"

3557source = "registry+https://github.com/rust-lang/crates.io-index"

3558checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"

3559

3560[[package]]

3561name = "flatbuffers"

3562version = "25.12.19"

3563source = "registry+https://github.com/rust-lang/crates.io-index"

3564checksum = "35f6839d7b3b98adde531effaf34f0c2badc6f4735d26fe74709d8e513a96ef3"

3565dependencies = [

3566 "bitflags 2.13.1",

3567 "rustc_version",

3568]

3569

3570[[package]]

3571name = "flate2"

3572version = "1.1.9"

3573source = "registry+https://github.com/rust-lang/crates.io-index"

3574checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"

3575dependencies = [

3576 "crc32fast",

3577 "miniz_oxide",

3578 "zlib-rs",

3579]

3580

3581[[package]]

3582name = "flume"

3583version = "0.12.0"

3584source = "registry+https://github.com/rust-lang/crates.io-index"

3585checksum = "5e139bc46ca777eb5efaf62df0ab8cc5fd400866427e56c68b22e414e53bd3be"

3586dependencies = [

3587 "futures-core",

3588 "futures-sink",

3589 "spin",

3590]

3591

3592[[package]]

3593name = "fnv"

3594version = "1.0.7"

3595source = "registry+https://github.com/rust-lang/crates.io-index"

3596checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"

3597

3598[[package]]

3599name = "foldhash"

3600version = "0.1.5"

3601source = "registry+https://github.com/rust-lang/crates.io-index"

3602checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"

3603

3604[[package]]

3605name = "foldhash"

3606version = "0.2.0"

3607source = "registry+https://github.com/rust-lang/crates.io-index"

3608checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"

3609

3610[[package]]

3611name = "foreign-types"

3612version = "0.3.2"

3613source = "registry+https://github.com/rust-lang/crates.io-index"

3614checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"

3615dependencies = [

3616 "foreign-types-shared",

3617]

3618

3619[[package]]

3620name = "foreign-types-shared"

3621version = "0.1.1"

3622source = "registry+https://github.com/rust-lang/crates.io-index"

3623checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"

3624

3625[[package]]

3626name = "form_urlencoded"

3627version = "1.2.2"

3628source = "registry+https://github.com/rust-lang/crates.io-index"

3629checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"

3630dependencies = [

3631 "percent-encoding 2.3.2",

3632]

3633

3634[[package]]

3635name = "forwarded-header-value"

3636version = "0.1.1"

3637source = "registry+https://github.com/rust-lang/crates.io-index"

3638checksum = "8835f84f38484cc86f110a805655697908257fb9a7af005234060891557198e9"

3639dependencies = [

3640 "nonempty 0.7.0",

3641 "thiserror 1.0.69",

3642]

3643

3644[[package]]

3645name = "foyer"

3646version = "0.22.3"

3647source = "registry+https://github.com/rust-lang/crates.io-index"

3648checksum = "3b0abc0b87814989efa711f9becd9f26969820e2d3905db27d10969c4bd45890"

3649dependencies = [

3650 "anyhow",

3651 "equivalent",

3652 "foyer-common",

3653 "foyer-memory",

3654 "foyer-storage",

3655 "foyer-tokio",

3656 "futures-util",

3657 "mea",

3658 "mixtrics",

3659 "pin-project",

3660 "serde",

3661 "tracing",

3662]

3663

3664[[package]]

3665name = "foyer-common"

3666version = "0.22.3"

3667source = "registry+https://github.com/rust-lang/crates.io-index"

3668checksum = "a3db80d5dece93adb7ad709c84578794724a9cba342a7e566c3551c7ec626789"

3669dependencies = [

3670 "anyhow",

3671 "bytes",

3672 "cfg-if",

3673 "foyer-tokio",

3674 "mixtrics",

3675 "parking_lot",

3676 "pin-project",

3677 "twox-hash",

3678]

3679

3680[[package]]

3681name = "foyer-intrusive-collections"

3682version = "0.10.0-dev"

3683source = "registry+https://github.com/rust-lang/crates.io-index"

3684checksum = "6e4fee46bea69e0596130e3210e65d3424e0ac1e6df3bde6636304bdf1ca4a3b"

3685dependencies = [

3686 "memoffset",

3687]

3688

3689[[package]]

3690name = "foyer-memory"

3691version = "0.22.3"

3692source = "registry+https://github.com/rust-lang/crates.io-index"

3693checksum = "db907f40a527ca2aa2f40a5f68b32ea58aa70f050cd233518e9ffd402cfba6ce"

3694dependencies = [

3695 "anyhow",

3696 "bitflags 2.13.1",

3697 "cmsketch",

3698 "equivalent",

3699 "foyer-common",

3700 "foyer-intrusive-collections",

3701 "foyer-tokio",

3702 "futures-util",

3703 "hashbrown 0.16.1",

3704 "itertools 0.14.0",

3705 "mea",

3706 "mixtrics",

3707 "parking_lot",

3708 "paste",

3709 "pin-project",

3710 "serde",

3711 "tracing",

3712]

3713

3714[[package]]

3715name = "foyer-storage"

3716version = "0.22.3"

3717source = "registry+https://github.com/rust-lang/crates.io-index"

3718checksum = "1983f1db3d0710e9c9d5fc116d9202dccd41a2d1e032572224f1aff5520aa958"

3719dependencies = [

3720 "allocator-api2",

3721 "anyhow",

3722 "bytes",

3723 "core_affinity",

3724 "equivalent",

3725 "fastant",

3726 "foyer-common",

3727 "foyer-memory",

3728 "foyer-tokio",

3729 "fs4",

3730 "futures-core",

3731 "futures-util",

3732 "hashbrown 0.16.1",

3733 "io-uring",

3734 "itertools 0.14.0",

3735 "libc",

3736 "lz4",

3737 "mea",

3738 "parking_lot",

3739 "pin-project",

3740 "rand 0.9.5",

3741 "tracing",

3742 "twox-hash",

3743 "zstd",

3744]

3745

3746[[package]]

3747name = "foyer-tokio"

3748version = "0.22.3"

3749source = "registry+https://github.com/rust-lang/crates.io-index"

3750checksum = "f6577b05a7ffad0db555aedf00bfe52af818220fc4c1c3a7a12520896fc38627"

3751dependencies = [

3752 "tokio",

3753]

3754

3755[[package]]

3756name = "fs4"

3757version = "0.13.1"

3758source = "registry+https://github.com/rust-lang/crates.io-index"

3759checksum = "8640e34b88f7652208ce9e88b1a37a2ae95227d84abec377ccd3c5cfeb141ed4"

3760dependencies = [

3761 "rustix",

3762 "windows-sys 0.59.0",

3763]

3764

3765[[package]]

3766name = "fs_extra"

3767version = "1.3.0"

3768source = "registry+https://github.com/rust-lang/crates.io-index"

3769checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"

3770

3771[[package]]

3772name = "fsst"

3773version = "7.0.0"

3774source = "registry+https://github.com/rust-lang/crates.io-index"

3775checksum = "bcd0ce0249ac12fd44fcde62d435c36d881952c2f0df4d1de24b45e1dbba5ddb"

3776dependencies = [

3777 "arrow-array",

3778 "rand 0.9.5",

3779]

3780

3781[[package]]

3782name = "fst"

3783version = "0.4.7"

3784source = "registry+https://github.com/rust-lang/crates.io-index"

3785checksum = "7ab85b9b05e3978cc9a9cf8fea7f01b494e1a09ed3037e16ba39edc7a29eb61a"

3786dependencies = [

3787 "utf8-ranges",

3788]

3789

3790[[package]]

3791name = "funty"

3792version = "2.0.0"

3793source = "registry+https://github.com/rust-lang/crates.io-index"

3794checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"

3795

3796[[package]]

3797name = "futures"

3798version = "0.3.34"

3799source = "registry+https://github.com/rust-lang/crates.io-index"

3800checksum = "9a31d2a3fbaaeb2af2368bbdd904aa8e812d3c04a1ee10d3171f52d556e5d0a3"

3801dependencies = [

3802 "futures-channel",

3803 "futures-core",

3804 "futures-executor",

3805 "futures-io",

3806 "futures-sink",

3807 "futures-task",

3808 "futures-util",

3809]

3810

3811[[package]]

3812name = "futures-channel"

3813version = "0.3.34"

3814source = "registry+https://github.com/rust-lang/crates.io-index"

3815checksum = "b1f9e3d69d39e4862ffed03ed071a76f9a13ba1d9109d355b0f0aa6b15e393c4"

3816dependencies = [

3817 "futures-core",

3818 "futures-sink",

3819]

3820

3821[[package]]

3822name = "futures-core"

3823version = "0.3.34"

3824source = "registry+https://github.com/rust-lang/crates.io-index"

3825checksum = "92d699e522242e69e3003b94ecc1f960f3a5e015aa7c5d7486e65ad01dd94f5e"

3826

3827[[package]]

3828name = "futures-executor"

3829version = "0.3.34"

3830source = "registry+https://github.com/rust-lang/crates.io-index"

3831checksum = "031b47cf1a3c6cc8bc2fc76cd437f521619387907d469316e7c0bc278f1f5432"

3832dependencies = [

3833 "futures-core",

3834 "futures-task",

3835 "futures-util",

3836]

3837

3838[[package]]

3839name = "futures-intrusive"

3840version = "0.5.0"

3841source = "registry+https://github.com/rust-lang/crates.io-index"

3842checksum = "1d930c203dd0b6ff06e0201a4a2fe9149b43c684fd4420555b26d21b1a02956f"

3843dependencies = [

3844 "futures-core",

3845 "lock_api",

3846 "parking_lot",

3847]

3848

3849[[package]]

3850name = "futures-io"

3851version = "0.3.34"

3852source = "registry+https://github.com/rust-lang/crates.io-index"

3853checksum = "53c0fa8157de1303bfffdaa1cc2a673bfffb60102f76b0ef4441659124373fed"

3854

3855[[package]]

3856name = "futures-lite"

3857version = "2.6.1"

3858source = "registry+https://github.com/rust-lang/crates.io-index"

3859checksum = "f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad"

3860dependencies = [

3861 "futures-core",

3862 "pin-project-lite",

3863]

3864

3865[[package]]

3866name = "futures-macro"

3867version = "0.3.34"

3868source = "registry+https://github.com/rust-lang/crates.io-index"

3869checksum = "9fb9654ba8355388abeb8dcb4fc62f511300867002afc858860463bdd9fe0c44"

3870dependencies = [

3871 "proc-macro2",

3872 "quote",

3873 "syn 3.0.3",

3874]

3875

3876[[package]]

3877name = "futures-sink"

3878version = "0.3.34"

3879source = "registry+https://github.com/rust-lang/crates.io-index"

3880checksum = "1944426bf7d03f1d14f708785e4b33efd750b36d48a157b836b3efc15ede8e1d"

3881

3882[[package]]

3883name = "futures-task"

3884version = "0.3.34"

3885source = "registry+https://github.com/rust-lang/crates.io-index"

3886checksum = "cd417de3d1d015fc3bfd2b1ea46dfc7bab72ef86f1cc7cc9c78e728b34a6d1fd"

3887

3888[[package]]

3889name = "futures-timer"

3890version = "3.0.4"

3891source = "registry+https://github.com/rust-lang/crates.io-index"

3892checksum = "af43fadb8a98512d547e37b4e92e0ced13e205c061b87b4623eff01d918d6968"

3893dependencies = [

3894 "gloo-timers",

3895 "send_wrapper",

3896]

3897

3898[[package]]

3899name = "futures-util"

3900version = "0.3.34"

3901source = "registry+https://github.com/rust-lang/crates.io-index"

3902checksum = "0d50a92467f8ba5dd6e3ee5d4bd04d73ab2e4e1c44474a0674821dfce14b79bc"

3903dependencies = [

3904 "futures-channel",

3905 "futures-core",

3906 "futures-io",

3907 "futures-macro",

3908 "futures-sink",

3909 "futures-task",

3910 "memchr",

3911 "pin-project-lite",

3912 "slab",

3913]

3914

3915[[package]]

3916name = "generator"

3917version = "0.8.9"

3918source = "registry+https://github.com/rust-lang/crates.io-index"

3919checksum = "b3b854b0e584ead1a33f18b2fcad7cf7be18b3875c78816b753639aa501513ae"

3920dependencies = [

3921 "cc",

3922 "cfg-if",

3923 "libc",

3924 "log 0.4.33",

3925 "rustversion",

3926 "windows-link",

3927 "windows-result",

3928]

3929

3930[[package]]

3931name = "generic-array"

3932version = "0.14.9"

3933source = "registry+https://github.com/rust-lang/crates.io-index"

3934checksum = "4bb6743198531e02858aeaea5398fcc883e71851fcbcb5a2f773e2fb6cb1edf2"

3935dependencies = [

3936 "typenum",

3937 "version_check 0.9.5",

3938 "zeroize",

3939]

3940

3941[[package]]

3942name = "generic-array"

3943version = "1.4.5"

3944source = "registry+https://github.com/rust-lang/crates.io-index"

3945checksum = "337d46834ee672ab3e48caca2cb0c78cc174fb12b3a68d0d88f99a0519a5e36e"

3946dependencies = [

3947 "generic-array 0.14.9",

3948 "rustversion",

3949 "typenum",

3950]

3951

3952[[package]]

3953name = "getrandom"

3954version = "0.1.16"

3955source = "registry+https://github.com/rust-lang/crates.io-index"

3956checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce"

3957dependencies = [

3958 "cfg-if",

3959 "libc",

3960 "wasi 0.9.0+wasi-snapshot-preview1",

3961]

3962

3963[[package]]

3964name = "getrandom"

3965version = "0.2.17"

3966source = "registry+https://github.com/rust-lang/crates.io-index"

3967checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"

3968dependencies = [

3969 "cfg-if",

3970 "js-sys",

3971 "libc",

3972 "wasi 0.11.1+wasi-snapshot-preview1",

3973 "wasm-bindgen",

3974]

3975

3976[[package]]

3977name = "getrandom"

3978version = "0.3.4"

3979source = "registry+https://github.com/rust-lang/crates.io-index"

3980checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"

3981dependencies = [

3982 "cfg-if",

3983 "libc",

3984 "r-efi 5.3.0",

3985 "wasip2",

3986]

3987

3988[[package]]

3989name = "getrandom"

3990version = "0.4.3"

3991source = "registry+https://github.com/rust-lang/crates.io-index"

3992checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099"

3993dependencies = [

3994 "cfg-if",

3995 "js-sys",

3996 "libc",

3997 "r-efi 6.0.0",

3998 "rand_core 0.10.1",

3999 "wasm-bindgen",

4000]

4001

4002[[package]]

4003name = "ghash"

4004version = "0.5.1"

4005source = "registry+https://github.com/rust-lang/crates.io-index"

4006checksum = "f0d8a4362ccb29cb0b265253fb0a2728f592895ee6854fd9bc13f2ffda266ff1"

4007dependencies = [

4008 "opaque-debug",

4009 "polyval 0.6.2",

4010]

4011

4012[[package]]

4013name = "ghash"

4014version = "0.6.0"

4015source = "registry+https://github.com/rust-lang/crates.io-index"

4016checksum = "2eecf2d5dc9b66b732b97707a0210906b1d30523eb773193ab777c0c84b3e8d5"

4017dependencies = [

4018 "polyval 0.7.3",

4019]

4020

4021[[package]]

4022name = "gif"

4023version = "0.14.2"

4024source = "registry+https://github.com/rust-lang/crates.io-index"

4025checksum = "ee8cfcc411d9adbbaba82fb72661cc1bcca13e8bba98b364e62b2dba8f960159"

4026dependencies = [

4027 "color_quant",

4028 "weezl",

4029]

4030

4031[[package]]

4032name = "git"

4033version = "1.0.0"

4034dependencies = [

4035 "async-graphql",

4036 "async-trait",

4037 "axum",

4038 "base64 0.23.1",

4039 "bytes",

4040 "cache",

4041 "config",

4042 "export",

4043 "flate2",

4044 "futures",

4045 "gitbaby",

4046 "gix",

4047 "globset",

4048 "http-body-util",

4049 "maud",

4050 "models",

4051 "pulldown-cmark",

4052 "rand 0.8.7",

4053 "redis",

4054 "russh",

4055 "sea-orm",

4056 "serde",

4057 "serde_json",

4058 "session",

4059 "sha2 0.11.0",

4060 "space",

4061 "ssh-key 0.6.7",

4062 "thiserror 2.0.20",

4063 "time 0.3.55",

4064 "tokio",

4065 "tokio-util",

4066 "tracing",

4067 "utoipa",

4068 "uuid",

4069]

4070

4071[[package]]

4072name = "gitbaby"

4073version = "0.1.0"

4074source = "git+https://gitea.gitdata.me/GitDataAi/GitBaby.git?rev=69bd99a#69bd99a23d6302be9acfb353e8c680472e259e69"

4075dependencies = [

4076 "async-trait",

4077 "foyer",

4078 "gix",

4079 "serde",

4080 "serde_json",

4081 "time 0.3.55",

4082 "tokio",

4083]

4084

4085[[package]]

4086name = "githost"

4087version = "1.0.0"

4088dependencies = [

4089 "anyhow",

4090 "axum",

4091 "config",

4092 "export",

4093 "git",

4094 "tokio",

4095 "tracing",

4096 "tracing-subscriber",

4097]

4098

4099[[package]]

4100name = "gix"

4101version = "0.86.0"

4102source = "registry+https://github.com/rust-lang/crates.io-index"

4103checksum = "bb3790fd8981cba7949f1ba924ef865d902df731627bc5998d14164063892fce"

4104dependencies = [

4105 "gix-actor",

4106 "gix-archive",

4107 "gix-attributes",

4108 "gix-blame",

4109 "gix-command",

4110 "gix-commitgraph",

4111 "gix-config",

4112 "gix-credentials",

4113 "gix-date",

4114 "gix-diff",

4115 "gix-dir",

4116 "gix-discover",

4117 "gix-error",

4118 "gix-features",

4119 "gix-filter",

4120 "gix-fs",

4121 "gix-glob",

4122 "gix-hash",

4123 "gix-hashtable",

4124 "gix-ignore",

4125 "gix-index",

4126 "gix-lock",

4127 "gix-mailmap",

4128 "gix-negotiate",

4129 "gix-object",

4130 "gix-odb",

4131 "gix-pack",

4132 "gix-path",

4133 "gix-pathspec",

4134 "gix-prompt",

4135 "gix-protocol",

4136 "gix-ref",

4137 "gix-refspec",

4138 "gix-revision",

4139 "gix-revwalk",

4140 "gix-sec",

4141 "gix-shallow",

4142 "gix-status",

4143 "gix-submodule",

4144 "gix-tempfile",

4145 "gix-trace",

4146 "gix-transport",

4147 "gix-traverse",

4148 "gix-url",

4149 "gix-utils",

4150 "gix-validate",

4151 "gix-worktree",

4152 "gix-worktree-state",

4153 "gix-worktree-stream",

4154 "gix-zlib",

4155 "nonempty 0.12.0",

4156 "parking_lot",

4157 "regex",

4158 "serde",

4159 "signal-hook",

4160 "smallvec",

4161 "thiserror 2.0.20",

4162]

4163

4164[[package]]

4165name = "gix-actor"

4166version = "0.41.2"

4167source = "registry+https://github.com/rust-lang/crates.io-index"

4168checksum = "33f9308ad6fd35b2a865cbe4117ac61b2be59e4a9ef1621c7a9794f7c8e52c5b"

4169dependencies = [

4170 "bstr",

4171 "gix-date",

4172 "gix-error",

4173 "serde",

4174]

4175

4176[[package]]

4177name = "gix-archive"

4178version = "0.35.0"

4179source = "registry+https://github.com/rust-lang/crates.io-index"

4180checksum = "6760ef6ef4edfa6449918977d59518ff209676f47e89bdce87a36a50be35e834"

4181dependencies = [

4182 "bstr",

4183 "gix-date",

4184 "gix-error",

4185 "gix-object",

4186 "gix-worktree-stream",

4187]

4188

4189[[package]]

4190name = "gix-attributes"

4191version = "0.34.0"

4192source = "registry+https://github.com/rust-lang/crates.io-index"

4193checksum = "c31c593692ebdc1e38858d9a2b56f6a594c501e24a38971fe6685571f5a07be0"

4194dependencies = [

4195 "bstr",

4196 "gix-features",

4197 "gix-glob",

4198 "gix-path",

4199 "gix-quote",

4200 "gix-trace",

4201 "serde",

4202 "smallvec",

4203 "thiserror 2.0.20",

4204 "unicode-bom",

4205]

4206

4207[[package]]

4208name = "gix-bitmap"

4209version = "0.3.3"

4210source = "registry+https://github.com/rust-lang/crates.io-index"

4211checksum = "7cd1d118d0f5d88b96e6f6e13b566475fef4797ead4a02c26fed36c1375066f7"

4212dependencies = [

4213 "gix-error",

4214]

4215

4216[[package]]

4217name = "gix-blame"

4218version = "0.16.0"

4219source = "registry+https://github.com/rust-lang/crates.io-index"

4220checksum = "b06d20ff0e88ada2dd852b3852727b664ec9baefdf653d1d4e722e858c52cd17"

4221dependencies = [

4222 "gix-commitgraph",

4223 "gix-date",

4224 "gix-diff",

4225 "gix-error",

4226 "gix-hash",

4227 "gix-object",

4228 "gix-revwalk",

4229 "gix-trace",

4230 "gix-traverse",

4231 "gix-worktree",

4232 "smallvec",

4233 "thiserror 2.0.20",

4234]

4235

4236[[package]]

4237name = "gix-chunk"

4238version = "0.7.3"

4239source = "registry+https://github.com/rust-lang/crates.io-index"

4240checksum = "b2a871e5cab12ba568845714473505deefffb3c04eb47f4708ce344cd459c1cc"

4241dependencies = [

4242 "gix-error",

4243]

4244

4245[[package]]

4246name = "gix-command"

4247version = "0.9.2"

4248source = "registry+https://github.com/rust-lang/crates.io-index"

4249checksum = "cf4363accdf6ef7ba861871d2d521ab7418a04aaaed919fadb022af71d379b12"

4250dependencies = [

4251 "bstr",

4252 "gix-path",

4253 "gix-quote",

4254 "gix-trace",

4255 "shell-words",

4256]

4257

4258[[package]]

4259name = "gix-commitgraph"

4260version = "0.38.0"

4261source = "registry+https://github.com/rust-lang/crates.io-index"

4262checksum = "a2cd7f054ae2727223fe46dd39c012f066b12f532962d336d29ee193261787da"

4263dependencies = [

4264 "bstr",

4265 "gix-chunk",

4266 "gix-error",

4267 "gix-hash",

4268 "memmap2",

4269 "nonempty 0.12.0",

4270 "serde",

4271]

4272

4273[[package]]

4274name = "gix-config"

4275version = "0.59.0"

4276source = "registry+https://github.com/rust-lang/crates.io-index"

4277checksum = "103d11bef95c467577ecfa8b7b86a22e65af3507b2c9bfa3809a4afbae7df301"

4278dependencies = [

4279 "bstr",

4280 "gix-config-value",

4281 "gix-features",

4282 "gix-glob",

4283 "gix-path",

4284 "gix-ref",

4285 "gix-sec",

4286 "gix-utils",

4287 "smallvec",

4288 "thiserror 2.0.20",

4289 "unicode-bom",

4290]

4291

4292[[package]]

4293name = "gix-config-value"

4294version = "0.19.1"

4295source = "registry+https://github.com/rust-lang/crates.io-index"

4296checksum = "6f6af5321bfd3711a279d6b244d58532ba1cfabf9eb6374791f19929d8970082"

4297dependencies = [

4298 "bitflags 2.13.1",

4299 "bstr",

4300 "gix-path",

4301 "libc",

4302 "thiserror 2.0.20",

4303]

4304

4305[[package]]

4306name = "gix-credentials"

4307version = "0.39.1"

4308source = "registry+https://github.com/rust-lang/crates.io-index"

4309checksum = "f9fbdb1c417980d05d547c19fc2b63344b5257c2387048d69ffe957bda142b59"

4310dependencies = [

4311 "bstr",

4312 "gix-command",

4313 "gix-config-value",

4314 "gix-date",

4315 "gix-path",

4316 "gix-prompt",

4317 "gix-quote",

4318 "gix-sec",

4319 "gix-trace",

4320 "gix-url",

4321 "serde",

4322 "thiserror 2.0.20",

4323]

4324

4325[[package]]

4326name = "gix-date"

4327version = "0.15.6"

4328source = "registry+https://github.com/rust-lang/crates.io-index"

4329checksum = "7e47b9e8cdc688296609b706428de570f88b1e0eed7156dde7b4a89d26fa4567"

4330dependencies = [

4331 "bstr",

4332 "gix-error",

4333 "itoa",

4334 "jiff",

4335 "serde",

4336]

4337

4338[[package]]

4339name = "gix-diff"

4340version = "0.66.0"

4341source = "registry+https://github.com/rust-lang/crates.io-index"

4342checksum = "fee7d89a3c507491cdfc57a1d1e0e300214720b4f7709ebc253e422f99822bfc"

4343dependencies = [

4344 "bstr",

4345 "gix-attributes",

4346 "gix-command",

4347 "gix-filter",

4348 "gix-fs",

4349 "gix-hash",

4350 "gix-imara-diff",

4351 "gix-index",

4352 "gix-object",

4353 "gix-path",

4354 "gix-pathspec",

4355 "gix-tempfile",

4356 "gix-trace",

4357 "gix-traverse",

4358 "gix-worktree",

4359 "thiserror 2.0.20",

4360]

4361

4362[[package]]

4363name = "gix-dir"

4364version = "0.28.0"

4365source = "registry+https://github.com/rust-lang/crates.io-index"

4366checksum = "f24bc78f283946ac64757c8a61ffa71f0230aa1e8d98cbb0771db479871dd5b6"

4367dependencies = [

4368 "bstr",

4369 "gix-discover",

4370 "gix-fs",

4371 "gix-ignore",

4372 "gix-index",

4373 "gix-object",

4374 "gix-path",

4375 "gix-pathspec",

4376 "gix-trace",

4377 "gix-utils",

4378 "gix-worktree",

4379 "thiserror 2.0.20",

4380]

4381

4382[[package]]

4383name = "gix-discover"

4384version = "0.54.0"

4385source = "registry+https://github.com/rust-lang/crates.io-index"

4386checksum = "b9f517766fa1101dfe2606c1a19a8ffa699099030995a9194445446dfe261bdf"

4387dependencies = [

4388 "bstr",

4389 "dunce",

4390 "gix-fs",

4391 "gix-path",

4392 "gix-ref",

4393 "gix-sec",

4394 "thiserror 2.0.20",

4395]

4396

4397[[package]]

4398name = "gix-error"

4399version = "0.2.5"

4400source = "registry+https://github.com/rust-lang/crates.io-index"

4401checksum = "4a9292309fd944e71b2a3c96d3c03a6feb8852db646febdde7cbb9f79cb5f329"

4402dependencies = [

4403 "bstr",

4404]

4405

4406[[package]]

4407name = "gix-features"

4408version = "0.49.1"

4409source = "registry+https://github.com/rust-lang/crates.io-index"

4410checksum = "39c0e59d9d253dcccc38c3a46b91bfb9b46bd63eed54fe1a719e12194884d52a"

4411dependencies = [

4412 "bytes",

4413 "bytesize",

4414 "crc32fast",

4415 "crossbeam-channel",

4416 "gix-path",

4417 "gix-trace",

4418 "gix-utils",

4419 "libc",

4420 "once_cell",

4421 "parking_lot",

4422 "prodash",

4423 "walkdir",

4424]

4425

4426[[package]]

4427name = "gix-filter"

4428version = "0.33.0"

4429source = "registry+https://github.com/rust-lang/crates.io-index"

4430checksum = "5e7b5dbf524d97e839f642930c76d7f011c0791e7d11d8148989ac5af7c76aa8"

4431dependencies = [

4432 "bstr",

4433 "encoding_rs",

4434 "gix-attributes",

4435 "gix-command",

4436 "gix-hash",

4437 "gix-object",

4438 "gix-packetline",

4439 "gix-path",

4440 "gix-quote",

4441 "gix-trace",

4442 "gix-utils",

4443 "smallvec",

4444 "thiserror 2.0.20",

4445]

4446

4447[[package]]

4448name = "gix-fs"

4449version = "0.22.1"

4450source = "registry+https://github.com/rust-lang/crates.io-index"

4451checksum = "ebcfa9fd253f25350a3b21b3dd74034a446098e373c6123d4cee3519894f12ef"

4452dependencies = [

4453 "bstr",

4454 "gix-features",

4455 "gix-path",

4456 "gix-utils",

4457 "thiserror 2.0.20",

4458]

4459

4460[[package]]

4461name = "gix-glob"

4462version = "0.27.1"

4463source = "registry+https://github.com/rust-lang/crates.io-index"

4464checksum = "b417cf515fd8c91468b578071f76d6cba716f8a1eccd853906bff4908b2c1413"

4465dependencies = [

4466 "bitflags 2.13.1",

4467 "bstr",

4468 "gix-features",

4469 "gix-path",

4470 "serde",

4471]

4472

4473[[package]]

4474name = "gix-hash"

4475version = "0.26.2"

4476source = "registry+https://github.com/rust-lang/crates.io-index"

4477checksum = "380b9c423a54f0821064b954b5a5ab25c660812f6a91da03c3f1cb4b10762aa5"

4478dependencies = [

4479 "faster-hex",

4480 "gix-features",

4481 "serde",

4482 "sha1-checked",

4483 "thiserror 2.0.20",

4484]

4485

4486[[package]]

4487name = "gix-hashtable"

4488version = "0.16.0"

4489source = "registry+https://github.com/rust-lang/crates.io-index"

4490checksum = "78fccd6fea3bcf0b39c076bae60ae49b08daaf538b950202101a981f9d3c01d3"

4491dependencies = [

4492 "gix-hash",

4493 "hashbrown 0.17.1",

4494 "parking_lot",

4495]

4496

4497[[package]]

4498name = "gix-ignore"

4499version = "0.22.1"

4500source = "registry+https://github.com/rust-lang/crates.io-index"

4501checksum = "65859a2f7de5e159d4344a5486ebf53b6bac22d5ec6afa836e47c10ae88a7f0f"

4502dependencies = [

4503 "bstr",

4504 "gix-glob",

4505 "gix-path",

4506 "gix-trace",

4507 "serde",

4508 "unicode-bom",

4509]

4510

4511[[package]]

4512name = "gix-imara-diff"

4513version = "0.2.5"

4514source = "registry+https://github.com/rust-lang/crates.io-index"

4515checksum = "1c91d8cffac8849493a82233811bd02b2b183b8cf39bf704de0fa0841b737595"

4516dependencies = [

4517 "bstr",

4518 "hashbrown 0.17.1",

4519]

4520

4521[[package]]

4522name = "gix-index"

4523version = "0.54.0"

4524source = "registry+https://github.com/rust-lang/crates.io-index"

4525checksum = "5009c4e7e9f9b4cfaaab1153e49133eb04d79c015b5702d6c3d2ab94271a89c6"

4526dependencies = [

4527 "bitflags 2.13.1",

4528 "bstr",

4529 "filetime",

4530 "fnv",

4531 "gix-bitmap",

4532 "gix-features",

4533 "gix-fs",

4534 "gix-hash",

4535 "gix-lock",

4536 "gix-object",

4537 "gix-traverse",

4538 "gix-utils",

4539 "gix-validate",

4540 "hashbrown 0.17.1",

4541 "itoa",

4542 "libc",

4543 "memmap2",

4544 "rustix",

4545 "serde",

4546 "smallvec",

4547 "thiserror 2.0.20",

4548]

4549

4550[[package]]

4551name = "gix-lock"

4552version = "24.0.0"

4553source = "registry+https://github.com/rust-lang/crates.io-index"

4554checksum = "d4c69157820343bf1c6e4b88b9808e920900de02e18aaf5862b30ada43814848"

4555dependencies = [

4556 "gix-tempfile",

4557 "gix-utils",

4558 "thiserror 2.0.20",

4559]

4560

4561[[package]]

4562name = "gix-mailmap"

4563version = "0.33.2"

4564source = "registry+https://github.com/rust-lang/crates.io-index"

4565checksum = "a824767d38b81475059cb01f5020a13fb96e7ed6bbf9851c7112b46ada78db48"

4566dependencies = [

4567 "bstr",

4568 "gix-actor",

4569 "gix-date",

4570 "gix-error",

4571 "serde",

4572]

4573

4574[[package]]

4575name = "gix-negotiate"

4576version = "0.34.0"

4577source = "registry+https://github.com/rust-lang/crates.io-index"

4578checksum = "2fa5aa789990f124e4f559b142cecfb60662cb4ae17006684ea9d668f4f07689"

4579dependencies = [

4580 "bitflags 2.13.1",

4581 "gix-commitgraph",

4582 "gix-date",

4583 "gix-hash",

4584 "gix-object",

4585 "gix-revwalk",

4586]

4587

4588[[package]]

4589name = "gix-object"

4590version = "0.63.0"

4591source = "registry+https://github.com/rust-lang/crates.io-index"

4592checksum = "0e48c235e7f886eb819fc878af75be889333dd3c38bee02ed7af48ae2cf596c4"

4593dependencies = [

4594 "bstr",

4595 "gix-actor",

4596 "gix-date",

4597 "gix-features",

4598 "gix-hash",

4599 "gix-hashtable",

4600 "gix-utils",

4601 "gix-validate",

4602 "itoa",

4603 "serde",

4604 "smallvec",

4605 "thiserror 2.0.20",

4606]

4607

4608[[package]]

4609name = "gix-odb"

4610version = "0.83.0"

4611source = "registry+https://github.com/rust-lang/crates.io-index"

4612checksum = "8dd494ffb5037e62b8220109e894d2861ff2150a2cacbfccdba57ae1ebab2b96"

4613dependencies = [

4614 "arc-swap",

4615 "gix-features",

4616 "gix-fs",

4617 "gix-hash",

4618 "gix-hashtable",

4619 "gix-object",

4620 "gix-pack",

4621 "gix-path",

4622 "gix-quote",

4623 "gix-zlib",

4624 "memmap2",

4625 "parking_lot",

4626 "serde",

4627 "tempfile",

4628 "thiserror 2.0.20",

4629]

4630

4631[[package]]

4632name = "gix-pack"

4633version = "0.73.0"

4634source = "registry+https://github.com/rust-lang/crates.io-index"

4635checksum = "6d5446127b269706e85998065267ddd2ccc3550179da6780b22fe496175ccb20"

4636dependencies = [

4637 "clru",

4638 "gix-chunk",

4639 "gix-error",

4640 "gix-features",

4641 "gix-hash",

4642 "gix-hashtable",

4643 "gix-object",

4644 "gix-path",

4645 "gix-zlib",

4646 "memmap2",

4647 "serde",

4648 "smallvec",

4649 "thiserror 2.0.20",

4650 "uluru",

4651]

4652

4653[[package]]

4654name = "gix-packetline"

4655version = "0.22.2"

4656source = "registry+https://github.com/rust-lang/crates.io-index"

4657checksum = "792bd92bea390087e6223b18d4d023decc36467de31e6b066b69b94beea1b9e2"

4658dependencies = [

4659 "bstr",

4660 "faster-hex",

4661 "gix-trace",

4662 "thiserror 2.0.20",

4663]

4664

4665[[package]]

4666name = "gix-path"

4667version = "0.12.6"

4668source = "registry+https://github.com/rust-lang/crates.io-index"

4669checksum = "38fc6f029ea67de83cbcbd33fd98c05a48360d2932b39d9fdacbc6eae802d475"

4670dependencies = [

4671 "bstr",

4672 "gix-trace",

4673 "gix-validate",

4674 "thiserror 2.0.20",

4675]

4676

4677[[package]]

4678name = "gix-pathspec"

4679version = "0.19.0"

4680source = "registry+https://github.com/rust-lang/crates.io-index"

4681checksum = "49f6fa5f8007f008187c3f60b4373209ca83d1cc947f35ede03e16cd15a4d137"

4682dependencies = [

4683 "bitflags 2.13.1",

4684 "bstr",

4685 "gix-attributes",

4686 "gix-config-value",

4687 "gix-glob",

4688 "gix-path",

4689 "thiserror 2.0.20",

4690]

4691

4692[[package]]

4693name = "gix-prompt"

4694version = "0.16.0"

4695source = "registry+https://github.com/rust-lang/crates.io-index"

4696checksum = "5cb1f1eb92d6f4c9d4c105a6ca912cff637fbd5cacbcbafa5deccd88bfaa3565"

26054697dependencies = [

2606 "async-graphql",

2607 "async-trait",

2608 "axum",

2609 "base64 0.23.1",

2610 "bytes",

2611 "cache",

2612 "config",

2613 "export",

2614 "flate2",

2615 "futures",

2616 "gitbaby",

2617 "gix",

2618 "globset",

2619 "http-body-util",

2620 "maud",

2621 "models",

2622 "pulldown-cmark",

2623 "rand 0.8.7",

2624 "redis",

2625 "russh",

2626 "sea-orm",

2627 "serde",

2628 "serde_json",

2629 "session",

2630 "sha2 0.11.0",

2631 "space",

2632 "ssh-key 0.6.7",

4698 "gix-command",

4699 "gix-config-value",

4700 "parking_lot",

4701 "rustix",

26334702 "thiserror 2.0.20",

2634 "time 0.3.55",

2635 "tokio",

2636 "tokio-util",

2637 "tracing",

2638 "utoipa",

2639 "uuid",

26404703]

26414704

26424705[[package]]

2643name = "gitbaby"

2644version = "0.1.0"

2645source = "git+https://gitea.gitdata.me/GitDataAi/GitBaby.git?rev=69bd99a#69bd99a23d6302be9acfb353e8c680472e259e69"

4706name = "gix-protocol"

4707version = "0.64.0"

4708source = "registry+https://github.com/rust-lang/crates.io-index"

4709checksum = "dede40e89c1e90f548415f50636bb051f6d9c60f68b8b710bc07825722d19588"

26464710dependencies = [

2647 "async-trait",

2648 "foyer",

2649 "gix",

4711 "bisync",

4712 "bstr",

4713 "gix-date",

4714 "gix-features",

4715 "gix-hash",

4716 "gix-ref",

4717 "gix-shallow",

4718 "gix-transport",

4719 "gix-utils",

4720 "nonempty 0.12.0",

26504721 "serde",

2651 "serde_json",

2652 "time 0.3.55",

2653 "tokio",

4722 "thiserror 2.0.20",

26544723]

26554724

26564725[[package]]

2657name = "githost"

2658version = "1.0.0"

4726name = "gix-quote"

4727version = "0.7.2"

4728source = "registry+https://github.com/rust-lang/crates.io-index"

4729checksum = "a6e541fc33cc2b783b7979040d445a0c86a2eca747c8faea4ca84230d06ae6ef"

26594730dependencies = [

2660 "anyhow",

2661 "axum",

2662 "config",

2663 "export",

2664 "git",

2665 "tokio",

2666 "tracing",

2667 "tracing-subscriber",

4731 "bstr",

4732 "gix-error",

4733 "gix-utils",

26684734]

26694735

26704736[[package]]

2671name = "gix"

2672version = "0.86.0"

4737name = "gix-ref"

4738version = "0.66.0"

26734739source = "registry+https://github.com/rust-lang/crates.io-index"

2674checksum = "bb3790fd8981cba7949f1ba924ef865d902df731627bc5998d14164063892fce"

4740checksum = "eeb0c90a8f6202ceaaa22996cbf837c943ccb2d8af9ff3490f0758305e6b7883"

26754741dependencies = [

26764742 "gix-actor",

2677 "gix-archive",

2678 "gix-attributes",

2679 "gix-blame",

2680 "gix-command",

2681 "gix-commitgraph",

2682 "gix-config",

2683 "gix-credentials",

2684 "gix-date",

2685 "gix-diff",

2686 "gix-dir",

2687 "gix-discover",

2688 "gix-error",

26894743 "gix-features",

2690 "gix-filter",

26914744 "gix-fs",

2692 "gix-glob",

26934745 "gix-hash",

2694 "gix-hashtable",

2695 "gix-ignore",

2696 "gix-index",

26974746 "gix-lock",

2698 "gix-mailmap",

2699 "gix-negotiate",

27004747 "gix-object",

2701 "gix-odb",

2702 "gix-pack",

27034748 "gix-path",

2704 "gix-pathspec",

2705 "gix-prompt",

2706 "gix-protocol",

2707 "gix-ref",

2708 "gix-refspec",

2709 "gix-revision",

2710 "gix-revwalk",

2711 "gix-sec",

2712 "gix-shallow",

2713 "gix-status",

2714 "gix-submodule",

27154749 "gix-tempfile",

2716 "gix-trace",

2717 "gix-transport",

2718 "gix-traverse",

2719 "gix-url",

27204750 "gix-utils",

27214751 "gix-validate",

2722 "gix-worktree",

2723 "gix-worktree-state",

2724 "gix-worktree-stream",

2725 "gix-zlib",

2726 "nonempty 0.12.0",

2727 "parking_lot",

2728 "regex",

4752 "memmap2",

27294753 "serde",

2730 "signal-hook",

4754 "thiserror 2.0.20",

4755]

4756

4757[[package]]

4758name = "gix-refspec"

4759version = "0.44.0"

4760source = "registry+https://github.com/rust-lang/crates.io-index"

4761checksum = "7406282cc0259b51f6aee299ca3d31279a020530363152a2e6c96e8a7f7bbc83"

4762dependencies = [

4763 "bstr",

4764 "gix-error",

4765 "gix-glob",

4766 "gix-hash",

4767 "gix-revision",

4768 "gix-validate",

27314769 "smallvec",

27324770 "thiserror 2.0.20",

27334771]

27344772

27354773[[package]]

2736name = "gix-actor"

2737version = "0.41.2"

4774name = "gix-revision"

4775version = "0.48.0"

27384776source = "registry+https://github.com/rust-lang/crates.io-index"

2739checksum = "33f9308ad6fd35b2a865cbe4117ac61b2be59e4a9ef1621c7a9794f7c8e52c5b"

4777checksum = "e55e09d4a1ecf2beecc8c09cafcad37979e805b31f588b0e957e191df5783681"

27404778dependencies = [

4779 "bitflags 2.13.1",

27414780 "bstr",

4781 "gix-commitgraph",

27424782 "gix-date",

27434783 "gix-error",

4784 "gix-hash",

4785 "gix-hashtable",

4786 "gix-object",

4787 "gix-revwalk",

4788 "gix-trace",

4789 "nonempty 0.12.0",

27444790 "serde",

27454791]

27464792

27474793[[package]]

2748name = "gix-archive"

2749version = "0.35.0"

4794name = "gix-revwalk"

4795version = "0.34.0"

27504796source = "registry+https://github.com/rust-lang/crates.io-index"

2751checksum = "6760ef6ef4edfa6449918977d59518ff209676f47e89bdce87a36a50be35e834"

4797checksum = "36c113c0a53294dc6280ffc06cbcc4f50f820397e97d6a00b429a44b8db26e29"

27524798dependencies = [

2753 "bstr",

4799 "gix-commitgraph",

27544800 "gix-date",

27554801 "gix-error",

4802 "gix-hash",

4803 "gix-hashtable",

27564804 "gix-object",

2757 "gix-worktree-stream",

4805 "smallvec",

4806 "thiserror 2.0.20",

4807]

4808

4809[[package]]

4810name = "gix-sec"

4811version = "0.14.2"

4812source = "registry+https://github.com/rust-lang/crates.io-index"

4813checksum = "af4fe6c152c1d50aea36f299825702cd37e303307832fec1d0fdd5844e47ce2f"

4814dependencies = [

4815 "bitflags 2.13.1",

4816 "gix-path",

4817 "libc",

4818 "serde",

4819 "windows-sys 0.61.2",

4820]

4821

4822[[package]]

4823name = "gix-shallow"

4824version = "0.13.0"

4825source = "registry+https://github.com/rust-lang/crates.io-index"

4826checksum = "1ecc9f4b40537043e4bbd7d3d1760e74fb8e7b07a546166b558acaa73ad97f4a"

4827dependencies = [

4828 "bstr",

4829 "gix-hash",

4830 "gix-lock",

4831 "nonempty 0.12.0",

4832 "serde",

4833 "thiserror 2.0.20",

27584834]

27594835

27604836[[package]]

2761name = "gix-attributes"

2762version = "0.34.0"

4837name = "gix-status"

4838version = "0.33.0"

27634839source = "registry+https://github.com/rust-lang/crates.io-index"

2764checksum = "c31c593692ebdc1e38858d9a2b56f6a594c501e24a38971fe6685571f5a07be0"

4840checksum = "5f83b1c74e69b90411fbfe89ccebc47aa49457ce4eb9b942b1311258fc863d22"

27654841dependencies = [

27664842 "bstr",

4843 "filetime",

4844 "gix-diff",

4845 "gix-dir",

27674846 "gix-features",

2768 "gix-glob",

4847 "gix-filter",

4848 "gix-fs",

4849 "gix-hash",

4850 "gix-index",

4851 "gix-object",

27694852 "gix-path",

2770 "gix-quote",

2771 "gix-trace",

2772 "serde",

2773 "smallvec",

4853 "gix-pathspec",

4854 "gix-worktree",

4855 "hashbrown 0.16.1",

4856 "portable-atomic",

27744857 "thiserror 2.0.20",

2775 "unicode-bom",

4858 "windows-sys 0.61.2",

27764859]

27774860

27784861[[package]]

2779name = "gix-bitmap"

2780version = "0.3.3"

4862name = "gix-submodule"

4863version = "0.33.0"

27814864source = "registry+https://github.com/rust-lang/crates.io-index"

2782checksum = "7cd1d118d0f5d88b96e6f6e13b566475fef4797ead4a02c26fed36c1375066f7"

4865checksum = "5fd98077a56d08886112e6b08dc94076d03539f4bc0b9d7880e4be2b8a640d8c"

27834866dependencies = [

2784 "gix-error",

4867 "bstr",

4868 "gix-config",

4869 "gix-path",

4870 "gix-pathspec",

4871 "gix-refspec",

4872 "gix-url",

4873 "thiserror 2.0.20",

27854874]

27864875

27874876[[package]]

2788name = "gix-blame"

2789version = "0.16.0"

4877name = "gix-tempfile"

4878version = "24.0.0"

27904879source = "registry+https://github.com/rust-lang/crates.io-index"

2791checksum = "b06d20ff0e88ada2dd852b3852727b664ec9baefdf653d1d4e722e858c52cd17"

4880checksum = "b675b920bd5a61d17ad542772f03ec34c60feb8ff683e1560c03ae967363731e"

27924881dependencies = [

2793 "gix-commitgraph",

2794 "gix-date",

2795 "gix-diff",

2796 "gix-error",

2797 "gix-hash",

2798 "gix-object",

2799 "gix-revwalk",

2800 "gix-trace",

2801 "gix-traverse",

2802 "gix-worktree",

2803 "smallvec",

2804 "thiserror 2.0.20",

4882 "dashmap",

4883 "gix-fs",

4884 "libc",

4885 "parking_lot",

4886 "signal-hook",

4887 "signal-hook-registry",

4888 "tempfile",

28054889]

28064890

28074891[[package]]

2808name = "gix-chunk"

2809version = "0.7.3"

4892name = "gix-trace"

4893version = "0.1.21"

28104894source = "registry+https://github.com/rust-lang/crates.io-index"

2811checksum = "b2a871e5cab12ba568845714473505deefffb3c04eb47f4708ce344cd459c1cc"

2812dependencies = [

2813 "gix-error",

2814]

4895checksum = "be3eb81d9dc914335923e50d52829c551feefd6a72d176c4130c546b67a60814"

28154896

28164897[[package]]

2817name = "gix-command"

2818version = "0.9.2"

4898name = "gix-transport"

4899version = "0.58.1"

28194900source = "registry+https://github.com/rust-lang/crates.io-index"

2820checksum = "cf4363accdf6ef7ba861871d2d521ab7418a04aaaed919fadb022af71d379b12"

4901checksum = "3f36d045b840f8aeee1a527e677eab1fbebfbbe94bf2e708fa81d0b4b742d5fc"

28214902dependencies = [

28224903 "bstr",

4904 "gix-command",

4905 "gix-features",

4906 "gix-packetline",

28234907 "gix-path",

28244908 "gix-quote",

2825 "gix-trace",

2826 "shell-words",

4909 "gix-sec",

4910 "gix-url",

4911 "serde",

4912 "thiserror 2.0.20",

28274913]

28284914

28294915[[package]]

2830name = "gix-commitgraph"

2831version = "0.38.0"

4916name = "gix-traverse"

4917version = "0.60.0"

28324918source = "registry+https://github.com/rust-lang/crates.io-index"

2833checksum = "a2cd7f054ae2727223fe46dd39c012f066b12f532962d336d29ee193261787da"

4919checksum = "008c5cd879e46e86b5c2469e633611978b18775d53d05668d691bc13088bd409"

28344920dependencies = [

2835 "bstr",

2836 "gix-chunk",

2837 "gix-error",

4921 "bitflags 2.13.1",

4922 "gix-commitgraph",

4923 "gix-date",

28384924 "gix-hash",

2839 "memmap2",

2840 "nonempty 0.12.0",

2841 "serde",

4925 "gix-hashtable",

4926 "gix-object",

4927 "gix-revwalk",

4928 "smallvec",

4929 "thiserror 2.0.20",

28424930]

28434931

28444932[[package]]

2845name = "gix-config"

2846version = "0.59.0"

4933name = "gix-url"

4934version = "0.37.1"

28474935source = "registry+https://github.com/rust-lang/crates.io-index"

2848checksum = "103d11bef95c467577ecfa8b7b86a22e65af3507b2c9bfa3809a4afbae7df301"

4936checksum = "31bdfc93aa880cda3272718a5879ce3aa7723fa13514320dd6608151607afe72"

28494937dependencies = [

28504938 "bstr",

2851 "gix-config-value",

2852 "gix-features",

2853 "gix-glob",

28544939 "gix-path",

2855 "gix-ref",

2856 "gix-sec",

28574940 "gix-utils",

2858 "smallvec",

4941 "percent-encoding 2.3.2",

4942 "serde",

28594943 "thiserror 2.0.20",

2860 "unicode-bom",

28614944]

28624945

28634946[[package]]

2864name = "gix-config-value"

2865version = "0.19.1"

4947name = "gix-utils"

4948version = "0.3.6"

28664949source = "registry+https://github.com/rust-lang/crates.io-index"

2867checksum = "6f6af5321bfd3711a279d6b244d58532ba1cfabf9eb6374791f19929d8970082"

4950checksum = "0da1c46491b49458a446cc76f0085860f8164c2290742e0aa8c653ce67240a97"

28684951dependencies = [

2869 "bitflags 2.13.1",

28704952 "bstr",

2871 "gix-path",

2872 "libc",

2873 "thiserror 2.0.20",

4953 "fastrand",

4954 "getrandom 0.4.3",

4955 "unicode-normalization",

28744956]

28754957

28764958[[package]]

2877name = "gix-credentials"

2878version = "0.39.1"

4959name = "gix-validate"

4960version = "0.11.4"

28794961source = "registry+https://github.com/rust-lang/crates.io-index"

2880checksum = "f9fbdb1c417980d05d547c19fc2b63344b5257c2387048d69ffe957bda142b59"

4962checksum = "4dae8780f63ed8a803b8bdabbd7aa5f5c5d74592c8b50eed875c1bb4f6545a6a"

28814963dependencies = [

28824964 "bstr",

2883 "gix-command",

2884 "gix-config-value",

2885 "gix-date",

2886 "gix-path",

2887 "gix-prompt",

2888 "gix-quote",

2889 "gix-sec",

2890 "gix-trace",

2891 "gix-url",

2892 "serde",

2893 "thiserror 2.0.20",

28944965]

28954966

28964967[[package]]

2897name = "gix-date"

2898version = "0.15.6"

4968name = "gix-worktree"

4969version = "0.55.0"

28994970source = "registry+https://github.com/rust-lang/crates.io-index"

2900checksum = "7e47b9e8cdc688296609b706428de570f88b1e0eed7156dde7b4a89d26fa4567"

4971checksum = "31eb8e675122e83585e461fe28f68ff8c5ed55b49017b697e7e76423ff973424"

29014972dependencies = [

29024973 "bstr",

2903 "gix-error",

2904 "itoa",

2905 "jiff",

4974 "gix-attributes",

4975 "gix-features",

4976 "gix-fs",

4977 "gix-glob",

4978 "gix-hash",

4979 "gix-ignore",

4980 "gix-index",

4981 "gix-object",

4982 "gix-path",

4983 "gix-validate",

29064984 "serde",

29074985]

29084986

29094987[[package]]

2910name = "gix-diff"

2911version = "0.66.0"

4988name = "gix-worktree-state"

4989version = "0.33.0"

29124990source = "registry+https://github.com/rust-lang/crates.io-index"

2913checksum = "fee7d89a3c507491cdfc57a1d1e0e300214720b4f7709ebc253e422f99822bfc"

4991checksum = "bc47372fc12b9fbea51b257bcc8d4970326cf5c7e42135bbfb5d72871bb30bd4"

29144992dependencies = [

29154993 "bstr",

2916 "gix-attributes",

2917 "gix-command",

4994 "gix-features",

29184995 "gix-filter",

29194996 "gix-fs",

2920 "gix-hash",

2921 "gix-imara-diff",

29224997 "gix-index",

29234998 "gix-object",

29244999 "gix-path",

2925 "gix-pathspec",

2926 "gix-tempfile",

2927 "gix-trace",

2928 "gix-traverse",

29295000 "gix-worktree",

5001 "io-close",

29305002 "thiserror 2.0.20",

29315003]

29325004

29335005[[package]]

2934name = "gix-dir"

2935version = "0.28.0"

5006name = "gix-worktree-stream"

5007version = "0.35.0"

29365008source = "registry+https://github.com/rust-lang/crates.io-index"

2937checksum = "f24bc78f283946ac64757c8a61ffa71f0230aa1e8d98cbb0771db479871dd5b6"

5009checksum = "3b088c8724e7be120c4798dd86925cf05332c9d356a463542578600c50c7a549"

29385010dependencies = [

2939 "bstr",

2940 "gix-discover",

5011 "gix-attributes",

5012 "gix-error",

5013 "gix-features",

5014 "gix-filter",

29415015 "gix-fs",

2942 "gix-ignore",

2943 "gix-index",

5016 "gix-hash",

29445017 "gix-object",

29455018 "gix-path",

2946 "gix-pathspec",

2947 "gix-trace",

2948 "gix-utils",

2949 "gix-worktree",

2950 "thiserror 2.0.20",

5019 "gix-traverse",

5020 "parking_lot",

29515021]

29525022

29535023[[package]]

2954name = "gix-discover"

2955version = "0.54.0"

5024name = "gix-zlib"

5025version = "0.1.0"

29565026source = "registry+https://github.com/rust-lang/crates.io-index"

2957checksum = "b9f517766fa1101dfe2606c1a19a8ffa699099030995a9194445446dfe261bdf"

5027checksum = "3e8813f5579b3075ff9c90f7c59cd2b62b4ebb639361f0911648b22d7446cc7c"

29585028dependencies = [

2959 "bstr",

2960 "dunce",

2961 "gix-fs",

2962 "gix-path",

2963 "gix-ref",

2964 "gix-sec",

5029 "serde",

29655030 "thiserror 2.0.20",

5031 "zlib-rs",

29665032]

29675033

29685034[[package]]

2969name = "gix-error"

2970version = "0.2.5"

5035name = "glob"

5036version = "0.3.4"

5037source = "registry+https://github.com/rust-lang/crates.io-index"

5038checksum = "e4eba85ea1d0a966a983acd07deee566e67395d2d96b6fb39e62b5a833f1eb0b"

5039

5040[[package]]

5041name = "globset"

5042version = "0.4.20"

29715043source = "registry+https://github.com/rust-lang/crates.io-index"

2972checksum = "4a9292309fd944e71b2a3c96d3c03a6feb8852db646febdde7cbb9f79cb5f329"

5044checksum = "07c34a9410465b45bd9787443bc7370f37735bad04b0f0cd57ff1a3186c98988"

29735045dependencies = [

5046 "aho-corasick",

29745047 "bstr",

5048 "log 0.4.33",

5049 "regex-automata",

5050 "regex-syntax",

29755051]

29765052

29775053[[package]]

2978name = "gix-features"

2979version = "0.49.1"

5054name = "gloo-timers"

5055version = "0.4.0"

29805056source = "registry+https://github.com/rust-lang/crates.io-index"

2981checksum = "39c0e59d9d253dcccc38c3a46b91bfb9b46bd63eed54fe1a719e12194884d52a"

5057checksum = "482ce8a491a501da4cd806bd190275363d674f2845005c6ddbd5d3e1dd54495d"

29825058dependencies = [

2983 "bytes",

2984 "bytesize",

2985 "crc32fast",

2986 "crossbeam-channel",

2987 "gix-path",

2988 "gix-trace",

2989 "gix-utils",

2990 "libc",

2991 "once_cell",

2992 "parking_lot",

2993 "prodash",

2994 "walkdir",

5059 "futures-channel",

5060 "futures-core",

5061 "js-sys",

5062 "wasm-bindgen",

29955063]

29965064

29975065[[package]]

2998name = "gix-filter"

2999version = "0.33.0"

5066name = "group"

5067version = "0.13.0"

30005068source = "registry+https://github.com/rust-lang/crates.io-index"

3001checksum = "5e7b5dbf524d97e839f642930c76d7f011c0791e7d11d8148989ac5af7c76aa8"

5069checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"

30025070dependencies = [

3003 "bstr",

3004 "encoding_rs",

3005 "gix-attributes",

3006 "gix-command",

3007 "gix-hash",

3008 "gix-object",

3009 "gix-packetline",

3010 "gix-path",

3011 "gix-quote",

3012 "gix-trace",

3013 "gix-utils",

3014 "smallvec",

3015 "thiserror 2.0.20",

5071 "ff 0.13.1",

5072 "rand_core 0.6.4",

5073 "subtle",

30165074]

30175075

30185076[[package]]

3019name = "gix-fs"

3020version = "0.22.1"

5077name = "group"

5078version = "0.14.0"

30215079source = "registry+https://github.com/rust-lang/crates.io-index"

3022checksum = "ebcfa9fd253f25350a3b21b3dd74034a446098e373c6123d4cee3519894f12ef"

5080checksum = "7fd1a1c7a5206c5b7a3f5a0d7ccd3ff85d0c8f5133d62a02680255b0004af5f4"

30235081dependencies = [

3024 "bstr",

3025 "gix-features",

3026 "gix-path",

3027 "gix-utils",

3028 "thiserror 2.0.20",

5082 "ff 0.14.0",

5083 "rand_core 0.10.1",

5084 "subtle",

30295085]

30305086

30315087[[package]]

3032name = "gix-glob"

3033version = "0.27.1"

5088name = "h2"

5089version = "0.3.27"

30345090source = "registry+https://github.com/rust-lang/crates.io-index"

3035checksum = "b417cf515fd8c91468b578071f76d6cba716f8a1eccd853906bff4908b2c1413"

5091checksum = "0beca50380b1fc32983fc1cb4587bfa4bb9e78fc259aad4a0032d2080309222d"

30365092dependencies = [

3037 "bitflags 2.13.1",

3038 "bstr",

3039 "gix-features",

3040 "gix-path",

3041 "serde",

5093 "bytes",

5094 "fnv",

5095 "futures-core",

5096 "futures-sink",

5097 "futures-util",

5098 "http 0.2.12",

5099 "indexmap 2.14.0",

5100 "slab",

5101 "tokio",

5102 "tokio-util",

5103 "tracing",

30425104]

30435105

30445106[[package]]

3045name = "gix-hash"

3046version = "0.26.2"

5107name = "h2"

5108version = "0.4.19"

30475109source = "registry+https://github.com/rust-lang/crates.io-index"

3048checksum = "380b9c423a54f0821064b954b5a5ab25c660812f6a91da03c3f1cb4b10762aa5"

5110checksum = "ef8e5e5a340588f4452631496976cf8636d4a7ecf600239fdc27615d2530bc16"

30495111dependencies = [

3050 "faster-hex",

3051 "gix-features",

3052 "serde",

3053 "sha1-checked",

3054 "thiserror 2.0.20",

5112 "atomic-waker",

5113 "bytes",

5114 "fnv",

5115 "futures-core",

5116 "futures-sink",

5117 "http 1.5.0",

5118 "indexmap 2.14.0",

5119 "slab",

5120 "tokio",

5121 "tokio-util",

5122 "tracing",

30555123]

30565124

30575125[[package]]

3058name = "gix-hashtable"

3059version = "0.16.0"

5126name = "half"

5127version = "2.7.1"

30605128source = "registry+https://github.com/rust-lang/crates.io-index"

3061checksum = "78fccd6fea3bcf0b39c076bae60ae49b08daaf538b950202101a981f9d3c01d3"

5129checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"

30625130dependencies = [

3063 "gix-hash",

3064 "hashbrown 0.17.1",

3065 "parking_lot",

5131 "cfg-if",

5132 "crunchy",

5133 "num-traits",

5134 "zerocopy",

30665135]

30675136

30685137[[package]]

3069name = "gix-ignore"

3070version = "0.22.1"

5138name = "handlebars"

5139version = "6.4.4"

30715140source = "registry+https://github.com/rust-lang/crates.io-index"

3072checksum = "65859a2f7de5e159d4344a5486ebf53b6bac22d5ec6afa836e47c10ae88a7f0f"

5141checksum = "75c54236f9045c8004a77942bebc52145b4844639db934a5c70fe08617fbe61a"

30735142dependencies = [

3074 "bstr",

3075 "gix-glob",

3076 "gix-path",

3077 "gix-trace",

5143 "derive_builder",

5144 "log 0.4.33",

5145 "num-order",

5146 "pest",

5147 "pest_derive",

30785148 "serde",

3079 "unicode-bom",

5149 "serde_json",

5150 "thiserror 2.0.20",

30805151]

30815152

30825153[[package]]

3083name = "gix-imara-diff"

3084version = "0.2.5"

5154name = "hash32"

5155version = "0.3.1"

30855156source = "registry+https://github.com/rust-lang/crates.io-index"

3086checksum = "1c91d8cffac8849493a82233811bd02b2b183b8cf39bf704de0fa0841b737595"

5157checksum = "47d60b12902ba28e2730cd37e95b8c9223af2808df9e902d4df49588d1470606"

30875158dependencies = [

3088 "bstr",

3089 "hashbrown 0.17.1",

5159 "byteorder",

30905160]

30915161

30925162[[package]]

3093name = "gix-index"

3094version = "0.54.0"

5163name = "hashbrown"

5164version = "0.12.3"

30955165source = "registry+https://github.com/rust-lang/crates.io-index"

3096checksum = "5009c4e7e9f9b4cfaaab1153e49133eb04d79c015b5702d6c3d2ab94271a89c6"

5166checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"

30975167dependencies = [

3098 "bitflags 2.13.1",

3099 "bstr",

3100 "filetime",

3101 "fnv",

3102 "gix-bitmap",

3103 "gix-features",

3104 "gix-fs",

3105 "gix-hash",

3106 "gix-lock",

3107 "gix-object",

3108 "gix-traverse",

3109 "gix-utils",

3110 "gix-validate",

3111 "hashbrown 0.17.1",

3112 "itoa",

3113 "libc",

3114 "memmap2",

3115 "rustix",

3116 "serde",

3117 "smallvec",

3118 "thiserror 2.0.20",

5168 "ahash 0.7.8",

31195169]

31205170

31215171[[package]]

3122name = "gix-lock"

3123version = "24.0.0"

5172name = "hashbrown"

5173version = "0.14.5"

5174source = "registry+https://github.com/rust-lang/crates.io-index"

5175checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"

5176

5177[[package]]

5178name = "hashbrown"

5179version = "0.15.5"

31245180source = "registry+https://github.com/rust-lang/crates.io-index"

3125checksum = "d4c69157820343bf1c6e4b88b9808e920900de02e18aaf5862b30ada43814848"

5181checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"

31265182dependencies = [

3127 "gix-tempfile",

3128 "gix-utils",

3129 "thiserror 2.0.20",

5183 "foldhash 0.1.5",

31305184]

31315185

31325186[[package]]

3133name = "gix-mailmap"

3134version = "0.33.2"

5187name = "hashbrown"

5188version = "0.16.1"

31355189source = "registry+https://github.com/rust-lang/crates.io-index"

3136checksum = "a824767d38b81475059cb01f5020a13fb96e7ed6bbf9851c7112b46ada78db48"

5190checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"

31375191dependencies = [

3138 "bstr",

3139 "gix-actor",

3140 "gix-date",

3141 "gix-error",

3142 "serde",

5192 "allocator-api2",

5193 "equivalent",

5194 "foldhash 0.2.0",

31435195]

31445196

31455197[[package]]

3146name = "gix-negotiate"

3147version = "0.34.0"

5198name = "hashbrown"

5199version = "0.17.1"

31485200source = "registry+https://github.com/rust-lang/crates.io-index"

3149checksum = "2fa5aa789990f124e4f559b142cecfb60662cb4ae17006684ea9d668f4f07689"

5201checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"

31505202dependencies = [

3151 "bitflags 2.13.1",

3152 "gix-commitgraph",

3153 "gix-date",

3154 "gix-hash",

3155 "gix-object",

3156 "gix-revwalk",

5203 "allocator-api2",

5204 "equivalent",

5205 "foldhash 0.2.0",

31575206]

31585207

31595208[[package]]

3160name = "gix-object"

3161version = "0.63.0"

5209name = "hashlink"

5210version = "0.11.1"

31625211source = "registry+https://github.com/rust-lang/crates.io-index"

3163checksum = "0e48c235e7f886eb819fc878af75be889333dd3c38bee02ed7af48ae2cf596c4"

5212checksum = "824e001ac4f3012dd16a264bec811403a67ca9deb6c102fc5049b32c4574b35f"

31645213dependencies = [

3165 "bstr",

3166 "gix-actor",

3167 "gix-date",

3168 "gix-features",

3169 "gix-hash",

3170 "gix-hashtable",

3171 "gix-utils",

3172 "gix-validate",

3173 "itoa",

3174 "serde",

3175 "smallvec",

3176 "thiserror 2.0.20",

5214 "hashbrown 0.16.1",

31775215]

31785216

31795217[[package]]

3180name = "gix-odb"

3181version = "0.83.0"

5218name = "heapless"

5219version = "0.8.0"

31825220source = "registry+https://github.com/rust-lang/crates.io-index"

3183checksum = "8dd494ffb5037e62b8220109e894d2861ff2150a2cacbfccdba57ae1ebab2b96"

5221checksum = "0bfb9eb618601c89945a70e254898da93b13be0388091d42117462b265bb3fad"

31845222dependencies = [

3185 "arc-swap",

3186 "gix-features",

3187 "gix-fs",

3188 "gix-hash",

3189 "gix-hashtable",

3190 "gix-object",

3191 "gix-pack",

3192 "gix-path",

3193 "gix-quote",

3194 "gix-zlib",

3195 "memmap2",

3196 "parking_lot",

3197 "serde",

3198 "tempfile",

3199 "thiserror 2.0.20",

5223 "hash32",

5224 "stable_deref_trait",

32005225]

32015226

32025227[[package]]

3203name = "gix-pack"

3204version = "0.73.0"

5228name = "heck"

5229version = "0.4.1"

32055230source = "registry+https://github.com/rust-lang/crates.io-index"

3206checksum = "6d5446127b269706e85998065267ddd2ccc3550179da6780b22fe496175ccb20"

3207dependencies = [

3208 "clru",

3209 "gix-chunk",

3210 "gix-error",

3211 "gix-features",

3212 "gix-hash",

3213 "gix-hashtable",

3214 "gix-object",

3215 "gix-path",

3216 "gix-zlib",

3217 "memmap2",

3218 "serde",

3219 "smallvec",

3220 "thiserror 2.0.20",

3221 "uluru",

3222]

5231checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"

32235232

32245233[[package]]

3225name = "gix-packetline"

3226version = "0.22.2"

5234name = "heck"

5235version = "0.5.0"

32275236source = "registry+https://github.com/rust-lang/crates.io-index"

3228checksum = "792bd92bea390087e6223b18d4d023decc36467de31e6b066b69b94beea1b9e2"

3229dependencies = [

3230 "bstr",

3231 "faster-hex",

3232 "gix-trace",

3233 "thiserror 2.0.20",

3234]

5237checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"

32355238

32365239[[package]]

3237name = "gix-path"

3238version = "0.12.5"

5240name = "hermit-abi"

5241version = "0.5.2"

32395242source = "registry+https://github.com/rust-lang/crates.io-index"

3240checksum = "2b075e730586bba7341304d6fc1b4efc1d10cf64532622521c0e07f30e661046"

3241dependencies = [

3242 "bstr",

3243 "gix-trace",

3244 "gix-validate",

3245 "thiserror 2.0.20",

3246]

5243checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"

32475244

32485245[[package]]

3249name = "gix-pathspec"

3250version = "0.19.0"

5246name = "hex"

5247version = "0.4.3"

32515248source = "registry+https://github.com/rust-lang/crates.io-index"

3252checksum = "49f6fa5f8007f008187c3f60b4373209ca83d1cc947f35ede03e16cd15a4d137"

3253dependencies = [

3254 "bitflags 2.13.1",

3255 "bstr",

3256 "gix-attributes",

3257 "gix-config-value",

3258 "gix-glob",

3259 "gix-path",

3260 "thiserror 2.0.20",

3261]

5249checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"

32625250

32635251[[package]]

3264name = "gix-prompt"

3265version = "0.16.0"

5252name = "hex-literal"

5253version = "1.1.0"

32665254source = "registry+https://github.com/rust-lang/crates.io-index"

3267checksum = "5cb1f1eb92d6f4c9d4c105a6ca912cff637fbd5cacbcbafa5deccd88bfaa3565"

3268dependencies = [

3269 "gix-command",

3270 "gix-config-value",

3271 "parking_lot",

3272 "rustix",

3273 "thiserror 2.0.20",

3274]

5255checksum = "e712f64ec3850b98572bffac52e2c6f282b29fe6c5fa6d42334b30be438d95c1"

32755256

32765257[[package]]

3277name = "gix-protocol"

3278version = "0.64.0"

5258name = "hf-hub"

5259version = "0.4.3"

32795260source = "registry+https://github.com/rust-lang/crates.io-index"

3280checksum = "dede40e89c1e90f548415f50636bb051f6d9c60f68b8b710bc07825722d19588"

5261checksum = "629d8f3bbeda9d148036d6b0de0a3ab947abd08ce90626327fc3547a49d59d97"

32815262dependencies = [

3282 "bisync",

3283 "bstr",

3284 "gix-date",

3285 "gix-features",

3286 "gix-hash",

3287 "gix-ref",

3288 "gix-shallow",

3289 "gix-transport",

3290 "gix-utils",

3291 "nonempty 0.12.0",

5263 "dirs 6.0.0",

5264 "http 1.5.0",

5265 "indicatif",

5266 "libc",

5267 "log 0.4.33",

5268 "rand 0.9.5",

5269 "reqwest 0.12.28",

32925270 "serde",

5271 "serde_json",

32935272 "thiserror 2.0.20",

5273 "ureq",

5274 "windows-sys 0.60.2",

32945275]

32955276

32965277[[package]]

3297name = "gix-quote"

3298version = "0.7.2"

5278name = "hkdf"

5279version = "0.13.0"

32995280source = "registry+https://github.com/rust-lang/crates.io-index"

3300checksum = "a6e541fc33cc2b783b7979040d445a0c86a2eca747c8faea4ca84230d06ae6ef"

5281checksum = "4aaa26c720c68b866f2c96ef5c1264b3e6f473fe5d4ce61cd44bbe913e553018"

33015282dependencies = [

3302 "bstr",

3303 "gix-error",

3304 "gix-utils",

5283 "hmac 0.13.0",

33055284]

33065285

33075286[[package]]

3308name = "gix-ref"

3309version = "0.66.0"

5287name = "hmac"

5288version = "0.12.1"

33105289source = "registry+https://github.com/rust-lang/crates.io-index"

3311checksum = "eeb0c90a8f6202ceaaa22996cbf837c943ccb2d8af9ff3490f0758305e6b7883"

5290checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"

33125291dependencies = [

3313 "gix-actor",

3314 "gix-features",

3315 "gix-fs",

3316 "gix-hash",

3317 "gix-lock",

3318 "gix-object",

3319 "gix-path",

3320 "gix-tempfile",

3321 "gix-utils",

3322 "gix-validate",

3323 "memmap2",

3324 "serde",

3325 "thiserror 2.0.20",

5292 "digest 0.10.7",

33265293]

33275294

33285295[[package]]

3329name = "gix-refspec"

3330version = "0.44.0"

5296name = "hmac"

5297version = "0.13.0"

33315298source = "registry+https://github.com/rust-lang/crates.io-index"

3332checksum = "7406282cc0259b51f6aee299ca3d31279a020530363152a2e6c96e8a7f7bbc83"

5299checksum = "6303bc9732ae41b04cb554b844a762b4115a61bfaa81e3e83050991eeb56863f"

33335300dependencies = [

3334 "bstr",

3335 "gix-error",

3336 "gix-glob",

3337 "gix-hash",

3338 "gix-revision",

3339 "gix-validate",

3340 "smallvec",

3341 "thiserror 2.0.20",

5301 "digest 0.11.3",

33425302]

33435303

33445304[[package]]

3345name = "gix-revision"

3346version = "0.48.0"

5305name = "http"

5306version = "0.2.12"

33475307source = "registry+https://github.com/rust-lang/crates.io-index"

3348checksum = "e55e09d4a1ecf2beecc8c09cafcad37979e805b31f588b0e957e191df5783681"

5308checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1"

33495309dependencies = [

3350 "bitflags 2.13.1",

3351 "bstr",

3352 "gix-commitgraph",

3353 "gix-date",

3354 "gix-error",

3355 "gix-hash",

3356 "gix-hashtable",

3357 "gix-object",

3358 "gix-revwalk",

3359 "gix-trace",

3360 "nonempty 0.12.0",

3361 "serde",

5310 "bytes",

5311 "fnv",

5312 "itoa",

33625313]

33635314

33645315[[package]]

3365name = "gix-revwalk"

3366version = "0.34.0"

5316name = "http"

5317version = "1.5.0"

33675318source = "registry+https://github.com/rust-lang/crates.io-index"

3368checksum = "36c113c0a53294dc6280ffc06cbcc4f50f820397e97d6a00b429a44b8db26e29"

5319checksum = "918d3568bebf352712bc2ef3d46a8bcf1a75b373be6539de198e9105cbbf9ce0"

33695320dependencies = [

3370 "gix-commitgraph",

3371 "gix-date",

3372 "gix-error",

3373 "gix-hash",

3374 "gix-hashtable",

3375 "gix-object",

3376 "smallvec",

3377 "thiserror 2.0.20",

5321 "bytes",

5322 "itoa",

33785323]

33795324

33805325[[package]]

3381name = "gix-sec"

3382version = "0.14.2"

5326name = "http-body"

5327version = "0.4.6"

33835328source = "registry+https://github.com/rust-lang/crates.io-index"

3384checksum = "af4fe6c152c1d50aea36f299825702cd37e303307832fec1d0fdd5844e47ce2f"

5329checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2"

33855330dependencies = [

3386 "bitflags 2.13.1",

3387 "gix-path",

3388 "libc",

3389 "serde",

3390 "windows-sys 0.61.2",

5331 "bytes",

5332 "http 0.2.12",

5333 "pin-project-lite",

33915334]

33925335

33935336[[package]]

3394name = "gix-shallow"

3395version = "0.13.0"

5337name = "http-body"

5338version = "1.1.0"

33965339source = "registry+https://github.com/rust-lang/crates.io-index"

3397checksum = "1ecc9f4b40537043e4bbd7d3d1760e74fb8e7b07a546166b558acaa73ad97f4a"

5340checksum = "ca2a8f2913ee65f60facd6a5905613afaa448497a0230cc41ce022d93290bc2c"

33985341dependencies = [

3399 "bstr",

3400 "gix-hash",

3401 "gix-lock",

3402 "nonempty 0.12.0",

3403 "serde",

3404 "thiserror 2.0.20",

5342 "bytes",

5343 "http 1.5.0",

34055344]

34065345

34075346[[package]]

3408name = "gix-status"

3409version = "0.33.0"

5347name = "http-body-util"

5348version = "0.1.5"

34105349source = "registry+https://github.com/rust-lang/crates.io-index"

3411checksum = "5f83b1c74e69b90411fbfe89ccebc47aa49457ce4eb9b942b1311258fc863d22"

5350checksum = "23169fe34a5fbcdd3f3862e78fb9b6fccd5f02a6dc6f732547005d45631ce71c"

34125351dependencies = [

3413 "bstr",

3414 "filetime",

3415 "gix-diff",

3416 "gix-dir",

3417 "gix-features",

3418 "gix-filter",

3419 "gix-fs",

3420 "gix-hash",

3421 "gix-index",

3422 "gix-object",

3423 "gix-path",

3424 "gix-pathspec",

3425 "gix-worktree",

3426 "hashbrown 0.16.1",

3427 "portable-atomic",

3428 "thiserror 2.0.20",

3429 "windows-sys 0.61.2",

5352 "bytes",

5353 "futures-core",

5354 "http 1.5.0",

5355 "http-body 1.1.0",

5356 "pin-project-lite",

34305357]

34315358

34325359[[package]]

3433name = "gix-submodule"

3434version = "0.33.0"

5360name = "httparse"

5361version = "1.10.1"

5362source = "registry+https://github.com/rust-lang/crates.io-index"

5363checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"

5364

5365[[package]]

5366name = "httpdate"

5367version = "1.0.3"

34355368source = "registry+https://github.com/rust-lang/crates.io-index"

3436checksum = "5fd98077a56d08886112e6b08dc94076d03539f4bc0b9d7880e4be2b8a640d8c"

3437dependencies = [

3438 "bstr",

3439 "gix-config",

3440 "gix-path",

3441 "gix-pathspec",

3442 "gix-refspec",

3443 "gix-url",

3444 "thiserror 2.0.20",

3445]

5369checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"

34465370

34475371[[package]]

3448name = "gix-tempfile"

3449version = "24.0.0"

5372name = "human_format"

5373version = "1.2.1"

34505374source = "registry+https://github.com/rust-lang/crates.io-index"

3451checksum = "b675b920bd5a61d17ad542772f03ec34c60feb8ff683e1560c03ae967363731e"

3452dependencies = [

3453 "dashmap",

3454 "gix-fs",

3455 "libc",

3456 "parking_lot",

3457 "signal-hook",

3458 "signal-hook-registry",

3459 "tempfile",

3460]

5375checksum = "eaec953f16e5bcf6b8a3cb3aa959b17e5577dbd2693e94554c462c08be22624b"

34615376

34625377[[package]]

3463name = "gix-trace"

3464version = "0.1.21"

5378name = "humantime"

5379version = "2.4.0"

34655380source = "registry+https://github.com/rust-lang/crates.io-index"

3466checksum = "be3eb81d9dc914335923e50d52829c551feefd6a72d176c4130c546b67a60814"

5381checksum = "15cdd26707701c53297e2fa6afb323d55fbc1d0810c3aec078ae3ef0424c3c15"

34675382

34685383[[package]]

3469name = "gix-transport"

3470version = "0.58.1"

5384name = "hybrid-array"

5385version = "0.4.14"

34715386source = "registry+https://github.com/rust-lang/crates.io-index"

3472checksum = "3f36d045b840f8aeee1a527e677eab1fbebfbbe94bf2e708fa81d0b4b742d5fc"

5387checksum = "707114b52a152fa7bdb290cd7cd5912d9467273b6d74e21b8d81aca1f8533f6b"

34735388dependencies = [

3474 "bstr",

3475 "gix-command",

3476 "gix-features",

3477 "gix-packetline",

3478 "gix-path",

3479 "gix-quote",

3480 "gix-sec",

3481 "gix-url",

3482 "serde",

3483 "thiserror 2.0.20",

5389 "ctutils",

5390 "subtle",

5391 "typenum",

5392 "zeroize",

34845393]

34855394

34865395[[package]]

3487name = "gix-traverse"

3488version = "0.60.0"

5396name = "hyper"

5397version = "0.10.16"

34895398source = "registry+https://github.com/rust-lang/crates.io-index"

3490checksum = "008c5cd879e46e86b5c2469e633611978b18775d53d05668d691bc13088bd409"

5399checksum = "0a0652d9a2609a968c14be1a9ea00bf4b1d64e2e1f53a1b51b6fff3a6e829273"

34915400dependencies = [

3492 "bitflags 2.13.1",

3493 "gix-commitgraph",

3494 "gix-date",

3495 "gix-hash",

3496 "gix-hashtable",

3497 "gix-object",

3498 "gix-revwalk",

3499 "smallvec",

3500 "thiserror 2.0.20",

5401 "base64 0.9.3",

5402 "httparse",

5403 "language-tags",

5404 "log 0.3.9",

5405 "mime 0.2.6",

5406 "num_cpus",

5407 "time 0.1.45",

5408 "traitobject",

5409 "typeable",

5410 "unicase 1.4.2",

5411 "url 1.7.2",

35015412]

35025413

35035414[[package]]

3504name = "gix-url"

3505version = "0.37.1"

5415name = "hyper"

5416version = "0.14.32"

35065417source = "registry+https://github.com/rust-lang/crates.io-index"

3507checksum = "31bdfc93aa880cda3272718a5879ce3aa7723fa13514320dd6608151607afe72"

5418checksum = "41dfc780fdec9373c01bae43289ea34c972e40ee3c9f6b3c8801a35f35586ce7"

35085419dependencies = [

3509 "bstr",

3510 "gix-path",

3511 "gix-utils",

3512 "percent-encoding 2.3.2",

3513 "serde",

3514 "thiserror 2.0.20",

5420 "bytes",

5421 "futures-channel",

5422 "futures-core",

5423 "futures-util",

5424 "h2 0.3.27",

5425 "http 0.2.12",

5426 "http-body 0.4.6",

5427 "httparse",

5428 "httpdate",

5429 "itoa",

5430 "pin-project-lite",

5431 "socket2 0.5.10",

5432 "tokio",

5433 "tower-service",

5434 "tracing",

5435 "want",

35155436]

35165437

35175438[[package]]

3518name = "gix-utils"

3519version = "0.3.6"

5439name = "hyper"

5440version = "1.11.0"

35205441source = "registry+https://github.com/rust-lang/crates.io-index"

3521checksum = "0da1c46491b49458a446cc76f0085860f8164c2290742e0aa8c653ce67240a97"

5442checksum = "d22053281f852e11534f5198498373cbb59295120a20771d90f7ed1897490a72"

35225443dependencies = [

3523 "bstr",

3524 "fastrand",

3525 "getrandom 0.4.3",

3526 "unicode-normalization",

5444 "atomic-waker",

5445 "bytes",

5446 "futures-channel",

5447 "futures-core",

5448 "h2 0.4.19",

5449 "http 1.5.0",

5450 "http-body 1.1.0",

5451 "httparse",

5452 "httpdate",

5453 "itoa",

5454 "pin-project-lite",

5455 "smallvec",

5456 "tokio",

5457 "want",

35275458]

35285459

35295460[[package]]

3530name = "gix-validate"

3531version = "0.11.4"

5461name = "hyper-native-tls"

5462version = "0.3.0"

35325463source = "registry+https://github.com/rust-lang/crates.io-index"

3533checksum = "4dae8780f63ed8a803b8bdabbd7aa5f5c5d74592c8b50eed875c1bb4f6545a6a"

5464checksum = "6d375598f442742b0e66208ee12501391f1c7ac0bafb90b4fe53018f81f06068"

35345465dependencies = [

3535 "bstr",

5466 "antidote",

5467 "hyper 0.10.16",

5468 "native-tls",

35365469]

35375470

35385471[[package]]

3539name = "gix-worktree"

3540version = "0.55.0"

5472name = "hyper-rustls"

5473version = "0.27.9"

35415474source = "registry+https://github.com/rust-lang/crates.io-index"

3542checksum = "31eb8e675122e83585e461fe28f68ff8c5ed55b49017b697e7e76423ff973424"

5475checksum = "33ca68d021ef39cf6463ab54c1d0f5daf03377b70561305bb89a8f83aab66e0f"

35435476dependencies = [

3544 "bstr",

3545 "gix-attributes",

3546 "gix-features",

3547 "gix-fs",

3548 "gix-glob",

3549 "gix-hash",

3550 "gix-ignore",

3551 "gix-index",

3552 "gix-object",

3553 "gix-path",

3554 "gix-validate",

3555 "serde",

5477 "http 1.5.0",

5478 "hyper 1.11.0",

5479 "hyper-util",

5480 "rustls",

5481 "rustls-native-certs",

5482 "tokio",

5483 "tokio-rustls",

5484 "tower-service",

5485 "webpki-roots 1.0.9",

35565486]

35575487

35585488[[package]]

3559name = "gix-worktree-state"

3560version = "0.33.0"

5489name = "hyper-tls"

5490version = "0.5.0"

35615491source = "registry+https://github.com/rust-lang/crates.io-index"

3562checksum = "bc47372fc12b9fbea51b257bcc8d4970326cf5c7e42135bbfb5d72871bb30bd4"

5492checksum = "d6183ddfa99b85da61a140bea0efc93fdf56ceaa041b37d553518030827f9905"

35635493dependencies = [

3564 "bstr",

3565 "gix-features",

3566 "gix-filter",

3567 "gix-fs",

3568 "gix-index",

3569 "gix-object",

3570 "gix-path",

3571 "gix-worktree",

3572 "io-close",

3573 "thiserror 2.0.20",

5494 "bytes",

5495 "hyper 0.14.32",

5496 "native-tls",

5497 "tokio",

5498 "tokio-native-tls",

35745499]

35755500

35765501[[package]]

3577name = "gix-worktree-stream"

3578version = "0.35.0"

5502name = "hyper-util"

5503version = "0.1.20"

35795504source = "registry+https://github.com/rust-lang/crates.io-index"

3580checksum = "3b088c8724e7be120c4798dd86925cf05332c9d356a463542578600c50c7a549"

5505checksum = "96547c2556ec9d12fb1578c4eaf448b04993e7fb79cbaad930a656880a6bdfa0"

35815506dependencies = [

3582 "gix-attributes",

3583 "gix-error",

3584 "gix-features",

3585 "gix-filter",

3586 "gix-fs",

3587 "gix-hash",

3588 "gix-object",

3589 "gix-path",

3590 "gix-traverse",

3591 "parking_lot",

5507 "base64 0.22.1",

5508 "bytes",

5509 "futures-channel",

5510 "futures-util",

5511 "http 1.5.0",

5512 "http-body 1.1.0",

5513 "hyper 1.11.0",

5514 "ipnet",

5515 "libc",

5516 "percent-encoding 2.3.2",

5517 "pin-project-lite",

5518 "socket2 0.6.5",

5519 "system-configuration",

5520 "tokio",

5521 "tower-service",

5522 "tracing",

5523 "windows-registry",

35925524]

35935525

35945526[[package]]

3595name = "gix-zlib"

3596version = "0.1.0"

5527name = "hyperloglogplus"

5528version = "0.4.1"

35975529source = "registry+https://github.com/rust-lang/crates.io-index"

3598checksum = "3e8813f5579b3075ff9c90f7c59cd2b62b4ebb639361f0911648b22d7446cc7c"

5530checksum = "621debdf94dcac33e50475fdd76d34d5ea9c0362a834b9db08c3024696c1fbe3"

35995531dependencies = [

36005532 "serde",

3601 "thiserror 2.0.20",

3602 "zlib-rs",

36035533]

36045534

36055535[[package]]

3606name = "globset"

3607version = "0.4.20"

5536name = "iana-time-zone"

5537version = "0.1.65"

36085538source = "registry+https://github.com/rust-lang/crates.io-index"

3609checksum = "07c34a9410465b45bd9787443bc7370f37735bad04b0f0cd57ff1a3186c98988"

5539checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470"

36105540dependencies = [

3611 "aho-corasick",

3612 "bstr",

5541 "android_system_properties",

5542 "core-foundation-sys",

5543 "iana-time-zone-haiku",

5544 "js-sys",

36135545 "log 0.4.33",

3614 "regex-automata",

3615 "regex-syntax",

5546 "wasm-bindgen",

5547 "windows-core",

36165548]

36175549

36185550[[package]]

3619name = "group"

3620version = "0.13.0"

5551name = "iana-time-zone-haiku"

5552version = "0.1.2"

36215553source = "registry+https://github.com/rust-lang/crates.io-index"

3622checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"

5554checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"

36235555dependencies = [

3624 "ff 0.13.1",

3625 "rand_core 0.6.4",

3626 "subtle",

5556 "cc",

36275557]

36285558

36295559[[package]]

3630name = "group"

3631version = "0.14.0"

5560name = "icu"

5561version = "2.3.0"

36325562source = "registry+https://github.com/rust-lang/crates.io-index"

3633checksum = "7fd1a1c7a5206c5b7a3f5a0d7ccd3ff85d0c8f5133d62a02680255b0004af5f4"

5563checksum = "8d5080b89807979ab05f8b6f3c6bbd580ece1512a6cf4cf800baa76937e488b3"

36345564dependencies = [

3635 "ff 0.14.0",

3636 "rand_core 0.10.1",

3637 "subtle",

5565 "icu_calendar",

5566 "icu_casemap",

5567 "icu_collator",

5568 "icu_collections",

5569 "icu_datetime",

5570 "icu_decimal",

5571 "icu_experimental",

5572 "icu_list",

5573 "icu_locale",

5574 "icu_normalizer",

5575 "icu_pattern",

5576 "icu_plurals",

5577 "icu_properties",

5578 "icu_provider",

5579 "icu_segmenter",

5580 "icu_time",

36385581]

36395582

36405583[[package]]

3641name = "h2"

3642version = "0.3.27"

5584name = "icu_calendar"

5585version = "2.3.0"

36435586source = "registry+https://github.com/rust-lang/crates.io-index"

3644checksum = "0beca50380b1fc32983fc1cb4587bfa4bb9e78fc259aad4a0032d2080309222d"

5587checksum = "58655df2f728e46e4eee80bddebefacf52ec3e77cdb925014b47c5a5905eb55c"

36455588dependencies = [

3646 "bytes",

3647 "fnv",

3648 "futures-core",

3649 "futures-sink",

3650 "futures-util",

3651 "http 0.2.12",

3652 "indexmap",

3653 "slab",

3654 "tokio",

3655 "tokio-util",

3656 "tracing",

5589 "calendrical_calculations",

5590 "displaydoc",

5591 "icu_calendar_data",

5592 "icu_locale_core",

5593 "icu_locale_fallback",

5594 "icu_provider",

5595 "ixdtf",

5596 "serde",

5597 "tinystr",

5598 "zerovec",

36575599]

36585600

36595601[[package]]

3660name = "half"

3661version = "2.7.1"

5602name = "icu_calendar_data"

5603version = "2.3.0"

36625604source = "registry+https://github.com/rust-lang/crates.io-index"

3663checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"

3664dependencies = [

3665 "cfg-if",

3666 "crunchy",

3667 "num-traits",

3668 "zerocopy",

3669]

5605checksum = "dc00caaa3fb3201ff7a18aa458e8c3ab042b9da154cfdf948bdde3936c31c36e"

36705606

36715607[[package]]

3672name = "handlebars"

3673version = "6.4.4"

5608name = "icu_casemap"

5609version = "2.3.0"

36745610source = "registry+https://github.com/rust-lang/crates.io-index"

3675checksum = "75c54236f9045c8004a77942bebc52145b4844639db934a5c70fe08617fbe61a"

5611checksum = "f2edfd120d8445de853cf53a1abec916f638f933a70a6f4bf8f7e2d7b7f884e9"

36765612dependencies = [

3677 "derive_builder",

3678 "log 0.4.33",

3679 "num-order",

3680 "pest",

3681 "pest_derive",

3682 "serde",

3683 "serde_json",

3684 "thiserror 2.0.20",

5613 "icu_casemap_data",

5614 "icu_collections",

5615 "icu_locale_core",

5616 "icu_properties",

5617 "icu_provider",

5618 "potential_utf",

5619 "writeable",

5620 "zerovec",

36855621]

36865622

36875623[[package]]

3688name = "hash32"

3689version = "0.3.1"

5624name = "icu_casemap_data"

5625version = "2.3.0"

36905626source = "registry+https://github.com/rust-lang/crates.io-index"

3691checksum = "47d60b12902ba28e2730cd37e95b8c9223af2808df9e902d4df49588d1470606"

3692dependencies = [

3693 "byteorder",

3694]

5627checksum = "059fcda0fc8d33effc6633a8cf0d8a3c17caf7d7c91918fba9918744f501e4e8"

36955628

36965629[[package]]

3697name = "hashbrown"

3698version = "0.12.3"

3699source = "registry+https://github.com/rust-lang/crates.io-index"

3700checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"

3701dependencies = [

3702 "ahash 0.7.8",

5630name = "icu_collator"

5631version = "2.3.0"

5632source = "registry+https://github.com/rust-lang/crates.io-index"

5633checksum = "59eea194d189ca897bcb960fd2130f9e7d53998460d4d32e85a60b10d5507cf4"

5634dependencies = [

5635 "icu_collator_data",

5636 "icu_collections",

5637 "icu_locale_core",

5638 "icu_locale_fallback",

5639 "icu_normalizer",

5640 "icu_properties",

5641 "icu_provider",

5642 "smallvec",

5643 "utf16_iter",

5644 "utf8_iter",

5645 "zerovec",

37035646]

37045647

37055648[[package]]

3706name = "hashbrown"

3707version = "0.14.5"

5649name = "icu_collator_data"

5650version = "2.3.0"

37085651source = "registry+https://github.com/rust-lang/crates.io-index"

3709checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"

5652checksum = "f7d7e54efdddeb1208c08dd5d32b53a879ac00d2d3d051b2255fd26821d16368"

37105653

37115654[[package]]

3712name = "hashbrown"

3713version = "0.16.1"

5655name = "icu_collections"

5656version = "2.3.0"

37145657source = "registry+https://github.com/rust-lang/crates.io-index"

3715checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"

5658checksum = "fa68d21081c4a05d5a901a1c62add574c77048b6a1c67be3b50ce0b60d4ca513"

37165659dependencies = [

3717 "allocator-api2",

3718 "equivalent",

3719 "foldhash",

5660 "displaydoc",

5661 "potential_utf",

5662 "serde",

5663 "utf8_iter",

5664 "yoke",

5665 "zerofrom",

5666 "zerovec",

37205667]

37215668

37225669[[package]]

3723name = "hashbrown"

3724version = "0.17.1"

5670name = "icu_datetime"

5671version = "2.3.0"

37255672source = "registry+https://github.com/rust-lang/crates.io-index"

3726checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"

5673checksum = "c44df99c4c5297b05653d1a1629f13bdc9fd4044acfbbaf30b15194a1eed4cd6"

37275674dependencies = [

3728 "allocator-api2",

3729 "equivalent",

3730 "foldhash",

5675 "displaydoc",

5676 "fixed_decimal",

5677 "icu_calendar",

5678 "icu_datetime_data",

5679 "icu_decimal",

5680 "icu_locale_core",

5681 "icu_locale_fallback",

5682 "icu_pattern",

5683 "icu_plurals",

5684 "icu_provider",

5685 "icu_time",

5686 "potential_utf",

5687 "tinystr",

5688 "writeable",

5689 "zerovec",

37315690]

37325691

37335692[[package]]

3734name = "hashlink"

3735version = "0.11.1"

5693name = "icu_datetime_data"

5694version = "2.3.0"

37365695source = "registry+https://github.com/rust-lang/crates.io-index"

3737checksum = "824e001ac4f3012dd16a264bec811403a67ca9deb6c102fc5049b32c4574b35f"

3738dependencies = [

3739 "hashbrown 0.16.1",

3740]

5696checksum = "8bb5555f6e4b42233f58564351ce16d73e9e6ebfce6bdcf29875d0cfc554d6a8"

37415697

37425698[[package]]

3743name = "heapless"

3744version = "0.8.0"

5699name = "icu_decimal"

5700version = "2.3.0"

37455701source = "registry+https://github.com/rust-lang/crates.io-index"

3746checksum = "0bfb9eb618601c89945a70e254898da93b13be0388091d42117462b265bb3fad"

5702checksum = "9eb8f655bba2d0c0459e43a5b0e6cd3cd388109898fb3d85d048165e8b0abd08"

37475703dependencies = [

3748 "hash32",

3749 "stable_deref_trait",

5704 "displaydoc",

5705 "fixed_decimal",

5706 "icu_decimal_data",

5707 "icu_locale_core",

5708 "icu_locale_fallback",

5709 "icu_pattern",

5710 "icu_plurals",

5711 "icu_provider",

5712 "serde",

5713 "writeable",

5714 "zerovec",

37505715]

37515716

37525717[[package]]

3753name = "heck"

3754version = "0.4.1"

5718name = "icu_decimal_data"

5719version = "2.3.0"

37555720source = "registry+https://github.com/rust-lang/crates.io-index"

3756checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"

5721checksum = "e4c887fc7d4c297cf3f9436864af9e3dba7f8be9415a6c2a7f392f3b1636298c"

37575722

37585723[[package]]

3759name = "heck"

3760version = "0.5.0"

5724name = "icu_experimental"

5725version = "0.6.0"

37615726source = "registry+https://github.com/rust-lang/crates.io-index"

3762checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"

5727checksum = "7c09609ad18e249b97a0afa20e19502c4d11ab039e6e35f5ecf48bebd4eedd7e"

5728dependencies = [

5729 "displaydoc",

5730 "either",

5731 "fixed_decimal",

5732 "icu_casemap",

5733 "icu_collections",

5734 "icu_decimal",

5735 "icu_experimental_data",

5736 "icu_list",

5737 "icu_locale",

5738 "icu_locale_core",

5739 "icu_locale_fallback",

5740 "icu_normalizer",

5741 "icu_pattern",

5742 "icu_plurals",

5743 "icu_properties",

5744 "icu_provider",

5745 "litemap",

5746 "num-bigint 0.4.8",

5747 "num-rational",

5748 "num-traits",

5749 "potential_utf",

5750 "smallvec",

5751 "tinystr",

5752 "writeable",

5753 "zerotrie",

5754 "zerovec",

5755]

37635756

37645757[[package]]

3765name = "hermit-abi"

3766version = "0.5.2"

5758name = "icu_experimental_data"

5759version = "0.6.0"

37675760source = "registry+https://github.com/rust-lang/crates.io-index"

3768checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"

5761checksum = "377481a8935d6774f410424d79a6dc8a09d9bd8def9560cff17abe755a246280"

37695762

37705763[[package]]

3771name = "hex"

3772version = "0.4.3"

5764name = "icu_list"

5765version = "2.3.0"

37735766source = "registry+https://github.com/rust-lang/crates.io-index"

3774checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"

5767checksum = "5a5c625125085fac4bf9ad111888a90c6ab9dc7bcaec392ca79cab417f46e3fb"

5768dependencies = [

5769 "icu_list_data",

5770 "icu_locale_fallback",

5771 "icu_provider",

5772 "regex-automata",

5773 "serde",

5774 "writeable",

5775 "zerovec",

5776]

37755777

37765778[[package]]

3777name = "hex-literal"

3778version = "1.1.0"

5779name = "icu_list_data"

5780version = "2.3.0"

37795781source = "registry+https://github.com/rust-lang/crates.io-index"

3780checksum = "e712f64ec3850b98572bffac52e2c6f282b29fe6c5fa6d42334b30be438d95c1"

5782checksum = "4ffef91ee351bd195a803115615a034dfb9f02bb48850980548c31cb78568a91"

37815783

37825784[[package]]

3783name = "hkdf"

3784version = "0.13.0"

5785name = "icu_locale"

5786version = "2.3.0"

37855787source = "registry+https://github.com/rust-lang/crates.io-index"

3786checksum = "4aaa26c720c68b866f2c96ef5c1264b3e6f473fe5d4ce61cd44bbe913e553018"

5788checksum = "250ec6d4ac288584d1d0ba29dbfad7737635b7b0e822441f4026a523e3fdb147"

37875789dependencies = [

3788 "hmac 0.13.0",

5790 "icu_collections",

5791 "icu_locale_core",

5792 "icu_locale_data",

5793 "icu_locale_fallback",

5794 "icu_provider",

5795 "tinystr",

5796 "zerovec",

37895797]

37905798

37915799[[package]]

3792name = "hmac"

3793version = "0.12.1"

5800name = "icu_locale_core"

5801version = "2.3.0"

37945802source = "registry+https://github.com/rust-lang/crates.io-index"

3795checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"

5803checksum = "d56e28588da92eee5c3201a6eff33fabdd49b62269c8938d4ff050ce4d900deb"

37965804dependencies = [

3797 "digest 0.10.7",

5805 "displaydoc",

5806 "litemap",

5807 "serde",

5808 "tinystr",

5809 "writeable",

5810 "zerovec",

37985811]

37995812

38005813[[package]]

3801name = "hmac"

3802version = "0.13.0"

5814name = "icu_locale_data"

5815version = "2.3.0"

5816source = "registry+https://github.com/rust-lang/crates.io-index"

5817checksum = "d37d91460e362a5cf58907cd7ce871411775ee6294e49a5cc8e6cec16dfa75ea"

5818

5819[[package]]

5820name = "icu_locale_fallback"

5821version = "2.3.0"

38035822source = "registry+https://github.com/rust-lang/crates.io-index"

3804checksum = "6303bc9732ae41b04cb554b844a762b4115a61bfaa81e3e83050991eeb56863f"

5823checksum = "251af8e57c9400e3eb58242fe5b8b1152b2a64fdf4cf632f923c38ccee6f2fa9"

38055824dependencies = [

3806 "digest 0.11.3",

5825 "icu_locale_core",

5826 "icu_locale_fallback_data",

5827 "icu_provider",

5828 "potential_utf",

5829 "tinystr",

5830 "zerovec",

38075831]

38085832

38095833[[package]]

3810name = "http"

3811version = "0.2.12"

5834name = "icu_locale_fallback_data"

5835version = "2.3.0"

38125836source = "registry+https://github.com/rust-lang/crates.io-index"

3813checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1"

3814dependencies = [

3815 "bytes",

3816 "fnv",

3817 "itoa",

3818]

5837checksum = "decf2a22ec8fa68f1a0c1129a3f8583f8f8bc24e8b9ccbe98ead99f62a4dc3a8"

38195838

38205839[[package]]

3821name = "http"

3822version = "1.5.0"

5840name = "icu_normalizer"

5841version = "2.3.0"

38235842source = "registry+https://github.com/rust-lang/crates.io-index"

3824checksum = "918d3568bebf352712bc2ef3d46a8bcf1a75b373be6539de198e9105cbbf9ce0"

5843checksum = "12f9cf5f235641ed274641dd81c3f28d870e276763d0797aeeab72317b1c646f"

38255844dependencies = [

3826 "bytes",

3827 "itoa",

5845 "icu_collections",

5846 "icu_normalizer_data",

5847 "icu_properties",

5848 "icu_provider",

5849 "smallvec",

5850 "utf16_iter",

5851 "utf8_iter",

5852 "write16",

5853 "zerovec",

38285854]

38295855

38305856[[package]]

3831name = "http-body"

3832version = "0.4.6"

5857name = "icu_normalizer_data"

5858version = "2.3.0"

38335859source = "registry+https://github.com/rust-lang/crates.io-index"

3834checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2"

3835dependencies = [

3836 "bytes",

3837 "http 0.2.12",

3838 "pin-project-lite",

3839]

5860checksum = "1563da1ed3e0b3bf3d74c9b85917ac9c56464d2f57242270c09c9e752f8021a0"

38405861

38415862[[package]]

3842name = "http-body"

3843version = "1.1.0"

5863name = "icu_pattern"

5864version = "0.5.0"

38445865source = "registry+https://github.com/rust-lang/crates.io-index"

3845checksum = "ca2a8f2913ee65f60facd6a5905613afaa448497a0230cc41ce022d93290bc2c"

5866checksum = "2b3db611446bd92c246b03e4aa0bafa71ddb194af431ddbb42b9d70e4bfce1a0"

38465867dependencies = [

3847 "bytes",

3848 "http 1.5.0",

5868 "displaydoc",

5869 "either",

5870 "serde",

5871 "writeable",

5872 "yoke",

5873 "zerovec",

38495874]

38505875

38515876[[package]]

3852name = "http-body-util"

3853version = "0.1.5"

5877name = "icu_plurals"

5878version = "2.3.0"

38545879source = "registry+https://github.com/rust-lang/crates.io-index"

3855checksum = "23169fe34a5fbcdd3f3862e78fb9b6fccd5f02a6dc6f732547005d45631ce71c"

5880checksum = "e475e6766ef87b1d3c1f97be6363995b0bfaeddbc789671615df598a97ff0593"

38565881dependencies = [

3857 "bytes",

3858 "futures-core",

3859 "http 1.5.0",

3860 "http-body 1.1.0",

3861 "pin-project-lite",

5882 "fixed_decimal",

5883 "icu_locale_fallback",

5884 "icu_plurals_data",

5885 "icu_provider",

5886 "zerovec",

38625887]

38635888

38645889[[package]]

3865name = "httparse"

3866version = "1.10.1"

5890name = "icu_plurals_data"

5891version = "2.3.0"

38675892source = "registry+https://github.com/rust-lang/crates.io-index"

3868checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"

5893checksum = "1251aa39a95e1333888e499b1263e1c196447a28948acf5bdabd82c046f153bf"

38695894

38705895[[package]]

3871name = "httpdate"

3872version = "1.0.3"

5896name = "icu_properties"

5897version = "2.3.0"

38735898source = "registry+https://github.com/rust-lang/crates.io-index"

3874checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"

5899checksum = "7e7ca276ad3145661a65914e6daf131ca5120cd3dcee8f8f3214b8875184a148"

5900dependencies = [

5901 "displaydoc",

5902 "icu_collections",

5903 "icu_locale_core",

5904 "icu_properties_data",

5905 "icu_provider",

5906 "serde",

5907 "zerotrie",

5908 "zerovec",

5909]

38755910

38765911[[package]]

3877name = "human_format"

3878version = "1.2.1"

5912name = "icu_properties_data"

5913version = "2.3.0"

38795914source = "registry+https://github.com/rust-lang/crates.io-index"

3880checksum = "eaec953f16e5bcf6b8a3cb3aa959b17e5577dbd2693e94554c462c08be22624b"

5915checksum = "e590f038c1464a96894fd6d10127e90a8be4509f56ff7ecef851b15cee0b7caa"

38815916

38825917[[package]]

3883name = "hybrid-array"

3884version = "0.4.14"

5918name = "icu_provider"

5919version = "2.3.0"

38855920source = "registry+https://github.com/rust-lang/crates.io-index"

3886checksum = "707114b52a152fa7bdb290cd7cd5912d9467273b6d74e21b8d81aca1f8533f6b"

5921checksum = "92a7ed671a6aad807a8651a2e1782a6598fda9ce5185dd8158549e95a91c6428"

38875922dependencies = [

3888 "ctutils",

3889 "subtle",

3890 "typenum",

3891 "zeroize",

5923 "displaydoc",

5924 "icu_locale_core",

5925 "serde",

5926 "stable_deref_trait",

5927 "writeable",

5928 "yoke",

5929 "zerofrom",

5930 "zerotrie",

5931 "zerovec",

38925932]

38935933

38945934[[package]]

3895name = "hyper"

3896version = "0.10.16"

5935name = "icu_segmenter"

5936version = "2.3.0"

38975937source = "registry+https://github.com/rust-lang/crates.io-index"

3898checksum = "0a0652d9a2609a968c14be1a9ea00bf4b1d64e2e1f53a1b51b6fff3a6e829273"

5938checksum = "82d07aafccd67af15d02512a6adf5896fbc5ed00f2e99b471d2efa14016db3db"

38995939dependencies = [

3900 "base64 0.9.3",

3901 "httparse",

3902 "language-tags",

3903 "log 0.3.9",

3904 "mime 0.2.6",

3905 "num_cpus",

3906 "time 0.1.45",

3907 "traitobject",

3908 "typeable",

3909 "unicase 1.4.2",

3910 "url 1.7.2",

5940 "core_maths",

5941 "icu_collections",

5942 "icu_locale_fallback",

5943 "icu_provider",

5944 "icu_segmenter_data",

5945 "potential_utf",

5946 "smallvec",

5947 "utf8_iter",

5948 "zerovec",

39115949]

39125950

39135951[[package]]

3914name = "hyper"

3915version = "0.14.32"

5952name = "icu_segmenter_data"

5953version = "2.3.0"

5954source = "registry+https://github.com/rust-lang/crates.io-index"

5955checksum = "ae293c039020f9ec10710af98d29ce6aa2051486638b49c9a6409f3b4a9e98ad"

5956

5957[[package]]

5958name = "icu_time"

5959version = "2.3.0"

39165960source = "registry+https://github.com/rust-lang/crates.io-index"

3917checksum = "41dfc780fdec9373c01bae43289ea34c972e40ee3c9f6b3c8801a35f35586ce7"

5961checksum = "af37e1c3b9f3ab564b619fdf4b22de169f6381eb0f7048e3ca454290c438126b"

39185962dependencies = [

3919 "bytes",

3920 "futures-channel",

3921 "futures-core",

3922 "futures-util",

3923 "h2",

3924 "http 0.2.12",

3925 "http-body 0.4.6",

3926 "httparse",

3927 "httpdate",

3928 "itoa",

3929 "pin-project-lite",

3930 "socket2 0.5.10",

3931 "tokio",

3932 "tower-service",

3933 "tracing",

3934 "want",

5963 "calendrical_calculations",

5964 "displaydoc",

5965 "icu_calendar",

5966 "icu_locale_core",

5967 "icu_provider",

5968 "icu_time_data",

5969 "ixdtf",

5970 "serde",

5971 "zerotrie",

5972 "zerovec",

39355973]

39365974

39375975[[package]]

3938name = "hyper"

3939version = "1.11.0"

5976name = "icu_time_data"

5977version = "2.3.0"

5978source = "registry+https://github.com/rust-lang/crates.io-index"

5979checksum = "005ff86fa5851a77fc0a977b72d717f777bd9230415a247219d7898aefb1517a"

5980

5981[[package]]

5982name = "ident_case"

5983version = "1.0.1"

39405984source = "registry+https://github.com/rust-lang/crates.io-index"

3941checksum = "d22053281f852e11534f5198498373cbb59295120a20771d90f7ed1897490a72"

3942dependencies = [

3943 "atomic-waker",

3944 "bytes",

3945 "futures-channel",

3946 "futures-core",

3947 "http 1.5.0",

3948 "http-body 1.1.0",

3949 "httparse",

3950 "httpdate",

3951 "itoa",

3952 "pin-project-lite",

3953 "smallvec",

3954 "tokio",

3955 "want",

3956]

5985checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"

39575986

39585987[[package]]

3959name = "hyper-native-tls"

3960version = "0.3.0"

5988name = "idna"

5989version = "0.1.5"

39615990source = "registry+https://github.com/rust-lang/crates.io-index"

3962checksum = "6d375598f442742b0e66208ee12501391f1c7ac0bafb90b4fe53018f81f06068"

5991checksum = "38f09e0f0b1fb55fdee1f17470ad800da77af5186a1a76c026b679358b7e844e"

39635992dependencies = [

3964 "antidote",

3965 "hyper 0.10.16",

3966 "native-tls",

5993 "matches",

5994 "unicode-bidi",

5995 "unicode-normalization",

39675996]

39685997

39695998[[package]]

3970name = "hyper-rustls"

3971version = "0.27.9"

5999name = "idna"

6000version = "1.1.0"

39726001source = "registry+https://github.com/rust-lang/crates.io-index"

3973checksum = "33ca68d021ef39cf6463ab54c1d0f5daf03377b70561305bb89a8f83aab66e0f"

6002checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"

39746003dependencies = [

3975 "http 1.5.0",

3976 "hyper 1.11.0",

3977 "hyper-util",

3978 "rustls",

3979 "tokio",

3980 "tokio-rustls",

3981 "tower-service",

3982 "webpki-roots",

6004 "idna_adapter",

6005 "smallvec",

6006 "utf8_iter",

39836007]

39846008

39856009[[package]]

3986name = "hyper-tls"

3987version = "0.5.0"

6010name = "idna_adapter"

6011version = "1.2.2"

39886012source = "registry+https://github.com/rust-lang/crates.io-index"

3989checksum = "d6183ddfa99b85da61a140bea0efc93fdf56ceaa041b37d553518030827f9905"

6013checksum = "cb68373c0d6620ef8105e855e7745e18b0d00d3bdb07fb532e434244cdb9a714"

39906014dependencies = [

3991 "bytes",

3992 "hyper 0.14.32",

3993 "native-tls",

3994 "tokio",

3995 "tokio-native-tls",

6015 "icu_normalizer",

6016 "icu_properties",

39966017]

39976018

39986019[[package]]

3999name = "hyper-util"

4000version = "0.1.20"

6020name = "image"

6021version = "0.25.10"

40016022source = "registry+https://github.com/rust-lang/crates.io-index"

4002checksum = "96547c2556ec9d12fb1578c4eaf448b04993e7fb79cbaad930a656880a6bdfa0"

6023checksum = "85ab80394333c02fe689eaf900ab500fbd0c2213da414687ebf995a65d5a6104"

40036024dependencies = [

4004 "base64 0.22.1",

4005 "bytes",

4006 "futures-channel",

4007 "futures-util",

4008 "http 1.5.0",

4009 "http-body 1.1.0",

4010 "hyper 1.11.0",

4011 "ipnet",

4012 "libc",

4013 "percent-encoding 2.3.2",

4014 "pin-project-lite",

4015 "socket2 0.6.5",

4016 "tokio",

4017 "tower-service",

4018 "tracing",

6025 "bytemuck",

6026 "byteorder-lite",

6027 "color_quant",

6028 "exr",

6029 "gif",

6030 "image-webp",

6031 "moxcms",

6032 "num-traits",

6033 "png",

6034 "qoi",

6035 "ravif",

6036 "rayon",

6037 "rgb",

6038 "tiff",

6039 "zune-core",

6040 "zune-jpeg",

40196041]

40206042

40216043[[package]]

4022name = "iana-time-zone"

4023version = "0.1.65"

6044name = "image-webp"

6045version = "0.2.4"

40246046source = "registry+https://github.com/rust-lang/crates.io-index"

4025checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470"

6047checksum = "525e9ff3e1a4be2fbea1fdf0e98686a6d98b4d8f937e1bf7402245af1909e8c3"

40266048dependencies = [

4027 "android_system_properties",

4028 "core-foundation-sys",

4029 "iana-time-zone-haiku",

4030 "js-sys",

4031 "log 0.4.33",

4032 "wasm-bindgen",

4033 "windows-core",

6049 "byteorder-lite",

6050 "quick-error",

40346051]

40356052

40366053[[package]]

4037name = "iana-time-zone-haiku"

4038version = "0.1.2"

6054name = "imgref"

6055version = "1.12.3"

40396056source = "registry+https://github.com/rust-lang/crates.io-index"

4040checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"

4041dependencies = [

4042 "cc",

4043]

6057checksum = "6e44b0a4eaa4c82f441d50a963f2d5f05a787240aeee097597033e72accfd22f"

40446058

40456059[[package]]

4046name = "icu"

4047version = "2.3.0"

6060name = "indexmap"

6061version = "1.9.3"

40486062source = "registry+https://github.com/rust-lang/crates.io-index"

4049checksum = "8d5080b89807979ab05f8b6f3c6bbd580ece1512a6cf4cf800baa76937e488b3"

6063checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"

40506064dependencies = [

4051 "icu_calendar",

4052 "icu_casemap",

4053 "icu_collator",

4054 "icu_collections",

4055 "icu_datetime",

4056 "icu_decimal",

4057 "icu_experimental",

4058 "icu_list",

4059 "icu_locale",

4060 "icu_normalizer",

4061 "icu_pattern",

4062 "icu_plurals",

4063 "icu_properties",

4064 "icu_provider",

4065 "icu_segmenter",

4066 "icu_time",

6065 "autocfg",

6066 "hashbrown 0.12.3",

6067 "serde",

40676068]

40686069

40696070[[package]]

4070name = "icu_calendar"

4071version = "2.3.0"

6071name = "indexmap"

6072version = "2.14.0"

40726073source = "registry+https://github.com/rust-lang/crates.io-index"

4073checksum = "58655df2f728e46e4eee80bddebefacf52ec3e77cdb925014b47c5a5905eb55c"

6074checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"

40746075dependencies = [

4075 "calendrical_calculations",

4076 "displaydoc",

4077 "icu_calendar_data",

4078 "icu_locale_core",

4079 "icu_locale_fallback",

4080 "icu_provider",

4081 "ixdtf",

6076 "equivalent",

6077 "hashbrown 0.17.1",

40826078 "serde",

4083 "tinystr",

4084 "zerovec",

6079 "serde_core",

40856080]

40866081

40876082[[package]]

4088name = "icu_calendar_data"

4089version = "2.3.0"

4090source = "registry+https://github.com/rust-lang/crates.io-index"

4091checksum = "dc00caaa3fb3201ff7a18aa458e8c3ab042b9da154cfdf948bdde3936c31c36e"

4092

4093[[package]]

4094name = "icu_casemap"

4095version = "2.3.0"

6083name = "indicatif"

6084version = "0.17.11"

40966085source = "registry+https://github.com/rust-lang/crates.io-index"

4097checksum = "f2edfd120d8445de853cf53a1abec916f638f933a70a6f4bf8f7e2d7b7f884e9"

6086checksum = "183b3088984b400f4cfac3620d5e076c84da5364016b4f49473de574b2586235"

40986087dependencies = [

4099 "icu_casemap_data",

4100 "icu_collections",

4101 "icu_locale_core",

4102 "icu_properties",

4103 "icu_provider",

4104 "potential_utf",

4105 "writeable",

4106 "zerovec",

6088 "console",

6089 "number_prefix",

6090 "portable-atomic",

6091 "unicode-width",

6092 "web-time",

41076093]

41086094

41096095[[package]]

4110name = "icu_casemap_data"

4111version = "2.3.0"

6096name = "inlinable_string"

6097version = "0.1.15"

41126098source = "registry+https://github.com/rust-lang/crates.io-index"

4113checksum = "059fcda0fc8d33effc6633a8cf0d8a3c17caf7d7c91918fba9918744f501e4e8"

6099checksum = "c8fae54786f62fb2918dcfae3d568594e50eb9b5c25bf04371af6fe7516452fb"

41146100

41156101[[package]]

4116name = "icu_collator"

4117version = "2.3.0"

6102name = "inout"

6103version = "0.1.4"

41186104source = "registry+https://github.com/rust-lang/crates.io-index"

4119checksum = "59eea194d189ca897bcb960fd2130f9e7d53998460d4d32e85a60b10d5507cf4"

6105checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"

41206106dependencies = [

4121 "icu_collator_data",

4122 "icu_collections",

4123 "icu_locale_core",

4124 "icu_locale_fallback",

4125 "icu_normalizer",

4126 "icu_properties",

4127 "icu_provider",

4128 "smallvec",

4129 "utf16_iter",

4130 "utf8_iter",

4131 "zerovec",

6107 "generic-array 0.14.9",

41326108]

41336109

41346110[[package]]

4135name = "icu_collator_data"

4136version = "2.3.0"

6111name = "inout"

6112version = "0.2.2"

41376113source = "registry+https://github.com/rust-lang/crates.io-index"

4138checksum = "f7d7e54efdddeb1208c08dd5d32b53a879ac00d2d3d051b2255fd26821d16368"

6114checksum = "4250ce6452e92010fdf7268ccc5d14faa80bb12fc741938534c58f16804e03c7"

6115dependencies = [

6116 "block-padding",

6117 "hybrid-array",

6118]

41396119

41406120[[package]]

4141name = "icu_collections"

4142version = "2.3.0"

6121name = "internal-russh-num-bigint"

6122version = "0.5.0"

41436123source = "registry+https://github.com/rust-lang/crates.io-index"

4144checksum = "fa68d21081c4a05d5a901a1c62add574c77048b6a1c67be3b50ce0b60d4ca513"

6124checksum = "ae8e22120c32fb4d19ec55fba35015f57095cd95a2e3b732e44457f5915b2ee8"

41456125dependencies = [

4146 "displaydoc",

4147 "potential_utf",

4148 "serde",

4149 "utf8_iter",

4150 "yoke",

4151 "zerofrom",

4152 "zerovec",

6126 "num-integer",

6127 "num-traits",

6128 "rand 0.10.2",

6129 "rand_core 0.10.1",

41536130]

41546131

41556132[[package]]

4156name = "icu_datetime"

4157version = "2.3.0"

6133name = "interpolate_name"

6134version = "0.2.4"

41586135source = "registry+https://github.com/rust-lang/crates.io-index"

4159checksum = "c44df99c4c5297b05653d1a1629f13bdc9fd4044acfbbaf30b15194a1eed4cd6"

6136checksum = "c34819042dc3d3971c46c2190835914dfbe0c3c13f61449b2997f4e9722dfa60"

41606137dependencies = [

4161 "displaydoc",

4162 "fixed_decimal",

4163 "icu_calendar",

4164 "icu_datetime_data",

4165 "icu_decimal",

4166 "icu_locale_core",

4167 "icu_locale_fallback",

4168 "icu_pattern",

4169 "icu_plurals",

4170 "icu_provider",

4171 "icu_time",

4172 "potential_utf",

4173 "tinystr",

4174 "writeable",

4175 "zerovec",

6138 "proc-macro2",

6139 "quote",

6140 "syn 2.0.119",

41766141]

41776142

41786143[[package]]

4179name = "icu_datetime_data"

4180version = "2.3.0"

6144name = "inventory"

6145version = "0.3.24"

41816146source = "registry+https://github.com/rust-lang/crates.io-index"

4182checksum = "8bb5555f6e4b42233f58564351ce16d73e9e6ebfce6bdcf29875d0cfc554d6a8"

6147checksum = "a4f0c30c76f2f4ccee3fe55a2435f691ca00c0e4bd87abe4f4a851b1d4dac39b"

6148dependencies = [

6149 "rustversion",

6150]

41836151

41846152[[package]]

4185name = "icu_decimal"

4186version = "2.3.0"

6153name = "io-close"

6154version = "0.3.7"

41876155source = "registry+https://github.com/rust-lang/crates.io-index"

4188checksum = "9eb8f655bba2d0c0459e43a5b0e6cd3cd388109898fb3d85d048165e8b0abd08"

6156checksum = "9cadcf447f06744f8ce713d2d6239bb5bde2c357a452397a9ed90c625da390bc"

41896157dependencies = [

4190 "displaydoc",

4191 "fixed_decimal",

4192 "icu_decimal_data",

4193 "icu_locale_core",

4194 "icu_locale_fallback",

4195 "icu_pattern",

4196 "icu_plurals",

4197 "icu_provider",

4198 "serde",

4199 "writeable",

4200 "zerovec",

6158 "libc",

6159 "winapi",

42016160]

42026161

42036162[[package]]

4204name = "icu_decimal_data"

4205version = "2.3.0"

6163name = "io-uring"

6164version = "0.7.14"

42066165source = "registry+https://github.com/rust-lang/crates.io-index"

4207checksum = "e4c887fc7d4c297cf3f9436864af9e3dba7f8be9415a6c2a7f392f3b1636298c"

4208

4209[[package]]

4210name = "icu_experimental"

4211version = "0.6.0"

4212source = "registry+https://github.com/rust-lang/crates.io-index"

4213checksum = "7c09609ad18e249b97a0afa20e19502c4d11ab039e6e35f5ecf48bebd4eedd7e"

6166checksum = "d64d8ca234d152948ceaede1f419b6a83983a5ecccaac05fb337a809c96d3aa6"

42146167dependencies = [

4215 "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",

4224 "icu_locale_core",

4225 "icu_locale_fallback",

4226 "icu_normalizer",

4227 "icu_pattern",

4228 "icu_plurals",

4229 "icu_properties",

4230 "icu_provider",

4231 "litemap",

4232 "num-bigint 0.4.8",

4233 "num-rational",

4234 "num-traits",

4235 "potential_utf",

4236 "smallvec",

4237 "tinystr",

4238 "writeable",

4239 "zerotrie",

4240 "zerovec",

6168 "bitflags 2.13.1",

6169 "cfg-if",

6170 "libc",

42416171]

42426172

42436173[[package]]

4244name = "icu_experimental_data"

4245version = "0.6.0"

6174name = "ipnet"

6175version = "2.12.1"

42466176source = "registry+https://github.com/rust-lang/crates.io-index"

4247checksum = "377481a8935d6774f410424d79a6dc8a09d9bd8def9560cff17abe755a246280"

6177checksum = "6a756c3fac73139e83f14c2d742155dd2b78d3ee56597b419a0579b7bdd6dd78"

42486178

42496179[[package]]

4250name = "icu_list"

4251version = "2.3.0"

4252source = "registry+https://github.com/rust-lang/crates.io-index"

4253checksum = "5a5c625125085fac4bf9ad111888a90c6ab9dc7bcaec392ca79cab417f46e3fb"

6180name = "issues"

6181version = "1.0.0"

42546182dependencies = [

4255 "icu_list_data",

4256 "icu_locale_fallback",

4257 "icu_provider",

4258 "regex-automata",

6183 "async-trait",

6184 "axum",

6185 "config",

6186 "email",

6187 "export",

6188 "models",

6189 "sea-orm",

42596190 "serde",

4260 "writeable",

4261 "zerovec",

6191 "serde_json",

6192 "session",

6193 "space",

6194 "time 0.3.55",

6195 "tracing",

6196 "utoipa",

6197 "uuid",

42626198]

42636199

42646200[[package]]

4265name = "icu_list_data"

4266version = "2.3.0"

6201name = "itertools"

6202version = "0.13.0"

42676203source = "registry+https://github.com/rust-lang/crates.io-index"

4268checksum = "4ffef91ee351bd195a803115615a034dfb9f02bb48850980548c31cb78568a91"

6204checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"

6205dependencies = [

6206 "either",

6207]

42696208

42706209[[package]]

4271name = "icu_locale"

4272version = "2.3.0"

6210name = "itertools"

6211version = "0.14.0"

42736212source = "registry+https://github.com/rust-lang/crates.io-index"

4274checksum = "250ec6d4ac288584d1d0ba29dbfad7737635b7b0e822441f4026a523e3fdb147"

6213checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"

42756214dependencies = [

4276 "icu_collections",

4277 "icu_locale_core",

4278 "icu_locale_data",

4279 "icu_locale_fallback",

4280 "icu_provider",

4281 "tinystr",

4282 "zerovec",

6215 "either",

42836216]

42846217

42856218[[package]]

4286name = "icu_locale_core"

4287version = "2.3.0"

6219name = "itertools"

6220version = "0.15.0"

42886221source = "registry+https://github.com/rust-lang/crates.io-index"

4289checksum = "d56e28588da92eee5c3201a6eff33fabdd49b62269c8938d4ff050ce4d900deb"

6222checksum = "8b4baf93f58d4425749ca49a51c50ebab072c5df6994d08fed93541c331481dc"

42906223dependencies = [

4291 "displaydoc",

4292 "litemap",

4293 "serde",

4294 "tinystr",

4295 "writeable",

4296 "zerovec",

6224 "either",

42976225]

42986226

42996227[[package]]

4300name = "icu_locale_data"

4301version = "2.3.0"

6228name = "itoa"

6229version = "1.0.18"

43026230source = "registry+https://github.com/rust-lang/crates.io-index"

4303checksum = "d37d91460e362a5cf58907cd7ce871411775ee6294e49a5cc8e6cec16dfa75ea"

6231checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"

43046232

43056233[[package]]

4306name = "icu_locale_fallback"

4307version = "2.3.0"

6234name = "ixdtf"

6235version = "0.6.6"

43086236source = "registry+https://github.com/rust-lang/crates.io-index"

4309checksum = "251af8e57c9400e3eb58242fe5b8b1152b2a64fdf4cf632f923c38ccee6f2fa9"

4310dependencies = [

4311 "icu_locale_core",

4312 "icu_locale_fallback_data",

4313 "icu_provider",

4314 "potential_utf",

4315 "tinystr",

4316 "zerovec",

4317]

6237checksum = "4d3667095d64c3ecffc96463a21157b04bf3e252f6e8d5750b20c02e33c194e3"

43186238

43196239[[package]]

4320name = "icu_locale_fallback_data"

4321version = "2.3.0"

6240name = "jieba-macros"

6241version = "0.9.0"

43226242source = "registry+https://github.com/rust-lang/crates.io-index"

4323checksum = "decf2a22ec8fa68f1a0c1129a3f8583f8f8bc24e8b9ccbe98ead99f62a4dc3a8"

6243checksum = "a29cfc5dcd898604c6f80363411fa6b6b08e27d1d253d6225b9cb6702ea02fc0"

6244dependencies = [

6245 "phf_codegen",

6246]

43246247

43256248[[package]]

4326name = "icu_normalizer"

4327version = "2.3.0"

6249name = "jieba-rs"

6250version = "0.9.0"

43286251source = "registry+https://github.com/rust-lang/crates.io-index"

4329checksum = "12f9cf5f235641ed274641dd81c3f28d870e276763d0797aeeab72317b1c646f"

6252checksum = "3245d6e9d1d5facbd6a23848d6b67e3439738ccbb4fa5a3d65da315ba1a910a2"

43306253dependencies = [

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",

6254 "cedarwood",

6255 "jieba-macros",

6256 "phf 0.13.1",

6257 "regex",

6258 "rustc-hash",

43406259]

43416260

43426261[[package]]

4343name = "icu_normalizer_data"

4344version = "2.3.0"

6262name = "jiff"

6263version = "0.2.35"

43456264source = "registry+https://github.com/rust-lang/crates.io-index"

4346checksum = "1563da1ed3e0b3bf3d74c9b85917ac9c56464d2f57242270c09c9e752f8021a0"

6265checksum = "668b7183bd07af9a4885f5c35b0cc5c83c4607a913c16b7e17291832910d2dcc"

6266dependencies = [

6267 "defmt",

6268 "jiff-core",

6269 "jiff-static",

6270 "jiff-tzdb-platform",

6271 "log 0.4.33",

6272 "portable-atomic",

6273 "portable-atomic-util",

6274 "serde_core",

6275 "windows-link",

6276]

43476277

43486278[[package]]

4349name = "icu_pattern"

4350version = "0.5.0"

6279name = "jiff-core"

6280version = "0.1.0"

43516281source = "registry+https://github.com/rust-lang/crates.io-index"

4352checksum = "2b3db611446bd92c246b03e4aa0bafa71ddb194af431ddbb42b9d70e4bfce1a0"

6282checksum = "7feca88439efe53da3754500c1851dedf3cb36c524dd5cf8225cc0794de95d09"

43536283dependencies = [

4354 "displaydoc",

4355 "either",

4356 "serde",

4357 "writeable",

4358 "yoke",

4359 "zerovec",

6284 "defmt",

43606285]

43616286

43626287[[package]]

4363name = "icu_plurals"

4364version = "2.3.0"

6288name = "jiff-static"

6289version = "0.2.35"

43656290source = "registry+https://github.com/rust-lang/crates.io-index"

4366checksum = "e475e6766ef87b1d3c1f97be6363995b0bfaeddbc789671615df598a97ff0593"

6291checksum = "3a69dcb3a21cfb32ce1cd056169337ca284af0766dd766e7878819b251a49204"

43676292dependencies = [

4368 "fixed_decimal",

4369 "icu_locale_fallback",

4370 "icu_plurals_data",

4371 "icu_provider",

4372 "zerovec",

6293 "jiff-core",

6294 "proc-macro2",

6295 "quote",

6296 "syn 2.0.119",

43736297]

43746298

43756299[[package]]

4376name = "icu_plurals_data"

4377version = "2.3.0"

6300name = "jiff-tzdb"

6301version = "0.1.8"

43786302source = "registry+https://github.com/rust-lang/crates.io-index"

4379checksum = "1251aa39a95e1333888e499b1263e1c196447a28948acf5bdabd82c046f153bf"

6303checksum = "142bd39932ad231f10513df9ab62661fead8719872150b7ad02a2df79f4e141e"

43806304

43816305[[package]]

4382name = "icu_properties"

4383version = "2.3.0"

6306name = "jiff-tzdb-platform"

6307version = "0.1.3"

43846308source = "registry+https://github.com/rust-lang/crates.io-index"

4385checksum = "7e7ca276ad3145661a65914e6daf131ca5120cd3dcee8f8f3214b8875184a148"

6309checksum = "875a5a69ac2bab1a891711cf5eccbec1ce0341ea805560dcd90b7a2e925132e8"

43866310dependencies = [

4387 "displaydoc",

4388 "icu_collections",

4389 "icu_locale_core",

4390 "icu_properties_data",

4391 "icu_provider",

4392 "serde",

4393 "zerotrie",

4394 "zerovec",

6311 "jiff-tzdb",

43956312]

43966313

43976314[[package]]

4398name = "icu_properties_data"

4399version = "2.3.0"

6315name = "jni"

6316version = "0.22.4"

44006317source = "registry+https://github.com/rust-lang/crates.io-index"

4401checksum = "e590f038c1464a96894fd6d10127e90a8be4509f56ff7ecef851b15cee0b7caa"

6318checksum = "5efd9a482cf3a427f00d6b35f14332adc7902ce91efb778580e180ff90fa3498"

6319dependencies = [

6320 "cfg-if",

6321 "combine",

6322 "jni-macros",

6323 "jni-sys",

6324 "log 0.4.33",

6325 "simd_cesu8",

6326 "thiserror 2.0.20",

6327 "walkdir",

6328 "windows-link",

6329]

44026330

44036331[[package]]

4404name = "icu_provider"

4405version = "2.3.0"

6332name = "jni-macros"

6333version = "0.22.4"

44066334source = "registry+https://github.com/rust-lang/crates.io-index"

4407checksum = "92a7ed671a6aad807a8651a2e1782a6598fda9ce5185dd8158549e95a91c6428"

6335checksum = "a00109accc170f0bdb141fed3e393c565b6f5e072365c3bd58f5b062591560a3"

44086336dependencies = [

4409 "displaydoc",

4410 "icu_locale_core",

4411 "serde",

4412 "stable_deref_trait",

4413 "writeable",

4414 "yoke",

4415 "zerofrom",

4416 "zerotrie",

4417 "zerovec",

6337 "proc-macro2",

6338 "quote",

6339 "rustc_version",

6340 "simd_cesu8",

6341 "syn 2.0.119",

44186342]

44196343

44206344[[package]]

4421name = "icu_segmenter"

4422version = "2.3.0"

6345name = "jni-sys"

6346version = "0.4.1"

44236347source = "registry+https://github.com/rust-lang/crates.io-index"

4424checksum = "82d07aafccd67af15d02512a6adf5896fbc5ed00f2e99b471d2efa14016db3db"

6348checksum = "c6377a88cb3910bee9b0fa88d4f42e1d2da8e79915598f65fb0c7ee14c878af2"

44256349dependencies = [

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",

6350 "jni-sys-macros",

44356351]

44366352

44376353[[package]]

4438name = "icu_segmenter_data"

4439version = "2.3.0"

6354name = "jni-sys-macros"

6355version = "0.4.1"

44406356source = "registry+https://github.com/rust-lang/crates.io-index"

4441checksum = "ae293c039020f9ec10710af98d29ce6aa2051486638b49c9a6409f3b4a9e98ad"

6357checksum = "38c0b942f458fe50cdac086d2f946512305e5631e720728f2a61aabcd47a6264"

6358dependencies = [

6359 "quote",

6360 "syn 2.0.119",

6361]

44426362

44436363[[package]]

4444name = "icu_time"

4445version = "2.3.0"

6364name = "jobserver"

6365version = "0.1.35"

44466366source = "registry+https://github.com/rust-lang/crates.io-index"

4447checksum = "af37e1c3b9f3ab564b619fdf4b22de169f6381eb0f7048e3ca454290c438126b"

6367checksum = "1c00acbd29eabad4a2392fa0e921c874934dbbf4194312ad20f04a0ed67a3cb3"

44486368dependencies = [

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",

6369 "getrandom 0.4.3",

6370 "libc",

44596371]

44606372

44616373[[package]]

4462name = "icu_time_data"

4463version = "2.3.0"

6374name = "js-sys"

6375version = "0.3.104"

44646376source = "registry+https://github.com/rust-lang/crates.io-index"

4465checksum = "005ff86fa5851a77fc0a977b72d717f777bd9230415a247219d7898aefb1517a"

6377checksum = "0e0c1080212aad755ea003d18543e8768dd432c48819efd73a7bf1e39b7a5a3a"

6378dependencies = [

6379 "cfg-if",

6380 "futures-util",

6381 "wasm-bindgen",

6382]

44666383

44676384[[package]]

4468name = "ident_case"

4469version = "1.0.1"

6385name = "jsonb"

6386version = "0.5.6"

44706387source = "registry+https://github.com/rust-lang/crates.io-index"

4471checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"

6388checksum = "eb98fb29636087c40ad0d1274d9a30c0c1e83e03ae93f6e7e89247b37fcc6953"

6389dependencies = [

6390 "byteorder",

6391 "ethnum",

6392 "fast-float2",

6393 "itoa",

6394 "jiff",

6395 "nom 8.0.0",

6396 "num-traits",

6397 "ordered-float 5.5.0",

6398 "rand 0.9.5",

6399 "serde",

6400 "serde_json",

6401 "zmij",

6402]

44726403

44736404[[package]]

4474name = "idna"

4475version = "0.1.5"

6405name = "kanaria"

6406version = "0.2.0"

44766407source = "registry+https://github.com/rust-lang/crates.io-index"

4477checksum = "38f09e0f0b1fb55fdee1f17470ad800da77af5186a1a76c026b679358b7e844e"

6408checksum = "c0f9d9652540055ac4fded998a73aca97d965899077ab1212587437da44196ff"

44786409dependencies = [

4479 "matches",

4480 "unicode-bidi",

4481 "unicode-normalization",

6410 "bitflags 1.3.2",

44826411]

44836412

44846413[[package]]

4485name = "idna"

4486version = "1.1.0"

6414name = "keccak"

6415version = "0.2.1"

44876416source = "registry+https://github.com/rust-lang/crates.io-index"

4488checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"

6417checksum = "ffd9697dc4a9a62e2da93389f34400b77a28f0287711263cabb203b3ccb9c0e4"

44896418dependencies = [

4490 "idna_adapter",

4491 "smallvec",

4492 "utf8_iter",

6419 "cfg-if",

6420 "cpufeatures 0.3.0",

44936421]

44946422

44956423[[package]]

4496name = "idna_adapter"

4497version = "1.2.2"

6424name = "kem"

6425version = "0.3.0"

44986426source = "registry+https://github.com/rust-lang/crates.io-index"

4499checksum = "cb68373c0d6620ef8105e855e7745e18b0d00d3bdb07fb532e434244cdb9a714"

6427checksum = "01737161ba802849cfd486b5bd209d38ba4943494c249a8126005170c7621edd"

45006428dependencies = [

4501 "icu_normalizer",

4502 "icu_properties",

6429 "crypto-common 0.2.2",

6430 "rand_core 0.10.1",

45036431]

45046432

45056433[[package]]

4506name = "indexmap"

4507version = "2.14.0"

6434name = "lance"

6435version = "7.0.0"

45086436source = "registry+https://github.com/rust-lang/crates.io-index"

4509checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"

6437checksum = "3944aca86f4c78f4da04af1c2bf33e664a2826b7af72972ad200d6b9de59019f"

45106438dependencies = [

4511 "equivalent",

4512 "hashbrown 0.17.1",

6439 "arc-swap",

6440 "arrow",

6441 "arrow-arith",

6442 "arrow-array",

6443 "arrow-buffer",

6444 "arrow-cast",

6445 "arrow-ipc",

6446 "arrow-ord",

6447 "arrow-row",

6448 "arrow-schema",

6449 "arrow-select",

6450 "async-recursion",

6451 "async-trait",

6452 "async_cell",

6453 "bitpacking",

6454 "byteorder",

6455 "bytes",

6456 "chrono",

6457 "crossbeam-queue",

6458 "crossbeam-skiplist",

6459 "dashmap",

6460 "datafusion",

6461 "datafusion-expr",

6462 "datafusion-functions",

6463 "datafusion-physical-expr",

6464 "datafusion-physical-plan",

6465 "deepsize",

6466 "either",

6467 "futures",

6468 "half",

6469 "humantime",

6470 "itertools 0.13.0",

6471 "lance-arrow",

6472 "lance-core",

6473 "lance-datafusion",

6474 "lance-encoding",

6475 "lance-file",

6476 "lance-index",

6477 "lance-io",

6478 "lance-linalg",

6479 "lance-namespace",

6480 "lance-table",

6481 "lance-tokenizer",

6482 "log 0.4.33",

6483 "moka",

6484 "object_store",

6485 "permutation",

6486 "pin-project",

6487 "prost",

6488 "prost-build",

6489 "prost-types",

6490 "rand 0.9.5",

6491 "rayon",

6492 "roaring",

6493 "semver",

45136494 "serde",

4514 "serde_core",

6495 "serde_json",

6496 "snafu 0.9.2",

6497 "tokio",

6498 "tokio-stream",

6499 "tokio-util",

6500 "tracing",

6501 "url 2.5.8",

6502 "uuid",

45156503]

45166504

45176505[[package]]

4518name = "inlinable_string"

4519version = "0.1.15"

6506name = "lance-arrow"

6507version = "7.0.0"

45206508source = "registry+https://github.com/rust-lang/crates.io-index"

4521checksum = "c8fae54786f62fb2918dcfae3d568594e50eb9b5c25bf04371af6fe7516452fb"

6509checksum = "253f4a0a70580c985b91e65e9ca6cad644825a4078de28d8efbacf3ffbd7ecdc"

6510dependencies = [

6511 "arrow-array",

6512 "arrow-buffer",

6513 "arrow-data",

6514 "arrow-ipc",

6515 "arrow-ord",

6516 "arrow-schema",

6517 "arrow-select",

6518 "bytes",

6519 "futures",

6520 "getrandom 0.2.17",

6521 "half",

6522 "jsonb",

6523 "num-traits",

6524 "rand 0.9.5",

6525]

45226526

45236527[[package]]

4524name = "inout"

4525version = "0.1.4"

6528name = "lance-bitpacking"

6529version = "7.0.0"

45266530source = "registry+https://github.com/rust-lang/crates.io-index"

4527checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"

6531checksum = "80c4d12521b1945041dd515a56aa0854973138e7ac12111c92572e33e4ecb593"

45286532dependencies = [

4529 "generic-array 0.14.9",

6533 "arrayref",

6534 "paste",

6535 "seq-macro",

45306536]

45316537

45326538[[package]]

4533name = "inout"

4534version = "0.2.2"

6539name = "lance-core"

6540version = "7.0.0"

45356541source = "registry+https://github.com/rust-lang/crates.io-index"

4536checksum = "4250ce6452e92010fdf7268ccc5d14faa80bb12fc741938534c58f16804e03c7"

6542checksum = "13f84020da5a484e2f07dd1796e09785ed7cd889857ebc4cb77e32ef214ee594"

45376543dependencies = [

4538 "block-padding",

4539 "hybrid-array",

6544 "arrow-array",

6545 "arrow-buffer",

6546 "arrow-schema",

6547 "async-trait",

6548 "byteorder",

6549 "bytes",

6550 "datafusion-common",

6551 "datafusion-sql",

6552 "deepsize",

6553 "futures",

6554 "itertools 0.13.0",

6555 "lance-arrow",

6556 "libc",

6557 "log 0.4.33",

6558 "moka",

6559 "num_cpus",

6560 "object_store",

6561 "pin-project",

6562 "prost",

6563 "rand 0.9.5",

6564 "roaring",

6565 "serde_json",

6566 "snafu 0.9.2",

6567 "tempfile",

6568 "tokio",

6569 "tokio-stream",

6570 "tokio-util",

6571 "tracing",

6572 "url 2.5.8",

45406573]

45416574

45426575[[package]]

4543name = "internal-russh-num-bigint"

4544version = "0.5.0"

6576name = "lance-datafusion"

6577version = "7.0.0"

45456578source = "registry+https://github.com/rust-lang/crates.io-index"

4546checksum = "ae8e22120c32fb4d19ec55fba35015f57095cd95a2e3b732e44457f5915b2ee8"

6579checksum = "7460597a66534a75987993d4dac5bc330586d99c5b79ae73367dbcbd4e29e576"

45476580dependencies = [

4548 "num-integer",

4549 "num-traits",

4550 "rand 0.10.2",

4551 "rand_core 0.10.1",

6581 "arrow",

6582 "arrow-array",

6583 "arrow-buffer",

6584 "arrow-cast",

6585 "arrow-ord",

6586 "arrow-schema",

6587 "arrow-select",

6588 "async-trait",

6589 "chrono",

6590 "datafusion",

6591 "datafusion-common",

6592 "datafusion-functions",

6593 "datafusion-physical-expr",

6594 "futures",

6595 "jsonb",

6596 "lance-arrow",

6597 "lance-core",

6598 "lance-datagen",

6599 "log 0.4.33",

6600 "pin-project",

6601 "prost",

6602 "prost-build",

6603 "tokio",

6604 "tracing",

45526605]

45536606

45546607[[package]]

4555name = "inventory"

4556version = "0.3.24"

6608name = "lance-datagen"

6609version = "7.0.0"

45576610source = "registry+https://github.com/rust-lang/crates.io-index"

4558checksum = "a4f0c30c76f2f4ccee3fe55a2435f691ca00c0e4bd87abe4f4a851b1d4dac39b"

6611checksum = "046f5506ed2271cd941a050de7bf535dd3aedc291aadec836a63fa56c5926e3b"

45596612dependencies = [

4560 "rustversion",

6613 "arrow",

6614 "arrow-array",

6615 "arrow-cast",

6616 "arrow-schema",

6617 "chrono",

6618 "futures",

6619 "half",

6620 "hex",

6621 "rand 0.9.5",

6622 "rand_distr",

6623 "rand_xoshiro",

6624 "random_word",

45616625]

45626626

45636627[[package]]

4564name = "io-close"

4565version = "0.3.7"

6628name = "lance-encoding"

6629version = "7.0.0"

45666630source = "registry+https://github.com/rust-lang/crates.io-index"

4567checksum = "9cadcf447f06744f8ce713d2d6239bb5bde2c357a452397a9ed90c625da390bc"

6631checksum = "7af54edf43dcf9d6a56cc636eb35d457e68373c6448dca3f0891b3325b4a24e6"

45686632dependencies = [

4569 "libc",

4570 "winapi",

6633 "arrow-arith",

6634 "arrow-array",

6635 "arrow-buffer",

6636 "arrow-cast",

6637 "arrow-data",

6638 "arrow-schema",

6639 "arrow-select",

6640 "bytemuck",

6641 "byteorder",

6642 "bytes",

6643 "fsst",

6644 "futures",

6645 "hex",

6646 "hyperloglogplus",

6647 "itertools 0.13.0",

6648 "lance-arrow",

6649 "lance-bitpacking",

6650 "lance-core",

6651 "log 0.4.33",

6652 "lz4",

6653 "num-traits",

6654 "prost",

6655 "prost-build",

6656 "rand 0.9.5",

6657 "strum 0.26.3",

6658 "tokio",

6659 "tracing",

6660 "xxhash-rust",

6661 "zstd",

45716662]

45726663

45736664[[package]]

4574name = "io-uring"

4575version = "0.7.14"

6665name = "lance-file"

6666version = "7.0.0"

45766667source = "registry+https://github.com/rust-lang/crates.io-index"

4577checksum = "d64d8ca234d152948ceaede1f419b6a83983a5ecccaac05fb337a809c96d3aa6"

6668checksum = "0772ae2d6207995dc1eb28aff9507f78e90b3362b58f311da001e9dc25f3d736"

45786669dependencies = [

4579 "bitflags 2.13.1",

4580 "cfg-if",

4581 "libc",

6670 "arrow-arith",

6671 "arrow-array",

6672 "arrow-buffer",

6673 "arrow-data",

6674 "arrow-schema",

6675 "arrow-select",

6676 "async-recursion",

6677 "async-trait",

6678 "byteorder",

6679 "bytes",

6680 "datafusion-common",

6681 "deepsize",

6682 "futures",

6683 "lance-arrow",

6684 "lance-core",

6685 "lance-encoding",

6686 "lance-io",

6687 "log 0.4.33",

6688 "num-traits",

6689 "object_store",

6690 "prost",

6691 "prost-build",

6692 "prost-types",

6693 "tokio",

6694 "tracing",

45826695]

45836696

45846697[[package]]

4585name = "ipnet"

4586version = "2.12.1"

6698name = "lance-index"

6699version = "7.0.0"

45876700source = "registry+https://github.com/rust-lang/crates.io-index"

4588checksum = "6a756c3fac73139e83f14c2d742155dd2b78d3ee56597b419a0579b7bdd6dd78"

4589

4590[[package]]

4591name = "issues"

4592version = "1.0.0"

6701checksum = "e71fbfb51096a903cb524fe0da716f5f15fbc4a6b6f84cd6dec21abf319c5e84"

45936702dependencies = [

6703 "arc-swap",

6704 "arrow",

6705 "arrow-arith",

6706 "arrow-array",

6707 "arrow-ord",

6708 "arrow-schema",

6709 "arrow-select",

6710 "async-channel",

6711 "async-recursion",

45946712 "async-trait",

4595 "axum",

4596 "config",

4597 "email",

4598 "export",

4599 "models",

4600 "sea-orm",

6713 "bitpacking",

6714 "bitvec",

6715 "bytes",

6716 "chrono",

6717 "crossbeam-queue",

6718 "datafusion",

6719 "datafusion-common",

6720 "datafusion-expr",

6721 "datafusion-physical-expr",

6722 "deepsize",

6723 "dirs 6.0.0",

6724 "fst",

6725 "futures",

6726 "half",

6727 "itertools 0.13.0",

6728 "jieba-rs",

6729 "jsonb",

6730 "lance-arrow",

6731 "lance-core",

6732 "lance-datafusion",

6733 "lance-datagen",

6734 "lance-encoding",

6735 "lance-file",

6736 "lance-io",

6737 "lance-linalg",

6738 "lance-table",

6739 "lance-tokenizer",

6740 "libm",

6741 "log 0.4.33",

6742 "ndarray",

6743 "num-traits",

6744 "object_store",

6745 "prost",

6746 "prost-build",

6747 "prost-types",

6748 "rand 0.9.5",

6749 "rand_distr",

6750 "rangemap",

6751 "rayon",

6752 "roaring",

46016753 "serde",

46026754 "serde_json",

4603 "session",

4604 "space",

4605 "time 0.3.55",

6755 "smallvec",

6756 "tempfile",

6757 "tokio",

46066758 "tracing",

4607 "utoipa",

6759 "twox-hash",

46086760 "uuid",

46096761]

46106762

46116763[[package]]

4612name = "itertools"

4613version = "0.14.0"

6764name = "lance-io"

6765version = "7.0.0"

46146766source = "registry+https://github.com/rust-lang/crates.io-index"

4615checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"

6767checksum = "bab8c98ef1b870b20541d27f3ca4efdf7c9f5c25214233be07d231ba88900219"

46166768dependencies = [

4617 "either",

6769 "arrow",

6770 "arrow-arith",

6771 "arrow-array",

6772 "arrow-buffer",

6773 "arrow-cast",

6774 "arrow-data",

6775 "arrow-schema",

6776 "arrow-select",

6777 "async-recursion",

6778 "async-trait",

6779 "byteorder",

6780 "bytes",

6781 "chrono",

6782 "deepsize",

6783 "futures",

6784 "http 1.5.0",

6785 "io-uring",

6786 "lance-arrow",

6787 "lance-core",

6788 "lance-namespace",

6789 "log 0.4.33",

6790 "moka",

6791 "object_store",

6792 "path_abs",

6793 "pin-project",

6794 "prost",

6795 "rand 0.9.5",

6796 "serde",

6797 "tempfile",

6798 "tokio",

6799 "tracing",

6800 "url 2.5.8",

46186801]

46196802

46206803[[package]]

4621name = "itertools"

4622version = "0.15.0"

6804name = "lance-linalg"

6805version = "7.0.0"

46236806source = "registry+https://github.com/rust-lang/crates.io-index"

4624checksum = "8b4baf93f58d4425749ca49a51c50ebab072c5df6994d08fed93541c331481dc"

6807checksum = "6b4c51cad0ac780b02dc4da48528479e7693c03e8d05390510bbc69ca2a9a1f1"

46256808dependencies = [

4626 "either",

6809 "arrow-array",

6810 "arrow-buffer",

6811 "arrow-schema",

6812 "cc",

6813 "deepsize",

6814 "half",

6815 "lance-arrow",

6816 "lance-core",

6817 "num-traits",

6818 "rand 0.9.5",

46276819]

46286820

46296821[[package]]

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"

6822name = "lance-namespace"

6823version = "7.0.0"

46446824source = "registry+https://github.com/rust-lang/crates.io-index"

4645checksum = "668b7183bd07af9a4885f5c35b0cc5c83c4607a913c16b7e17291832910d2dcc"

6825checksum = "014e8332ca0615506342e0d3af608639864b68396973be14239f09c9f21f1fc2"

46466826dependencies = [

4647 "defmt",

4648 "jiff-core",

4649 "jiff-static",

4650 "jiff-tzdb-platform",

4651 "log 0.4.33",

4652 "portable-atomic",

4653 "portable-atomic-util",

4654 "serde_core",

4655 "windows-link",

6827 "arrow",

6828 "async-trait",

6829 "bytes",

6830 "lance-core",

6831 "lance-namespace-reqwest-client",

6832 "snafu 0.9.2",

46566833]

46576834

46586835[[package]]

4659name = "jiff-core"

4660version = "0.1.0"

6836name = "lance-namespace-impls"

6837version = "7.0.0"

46616838source = "registry+https://github.com/rust-lang/crates.io-index"

4662checksum = "7feca88439efe53da3754500c1851dedf3cb36c524dd5cf8225cc0794de95d09"

6839checksum = "e8d1231906a3cf92dd3dcda7d14a09c4835af6cd2bcd76dfd2481e87f20a282d"

46636840dependencies = [

4664 "defmt",

6841 "arrow",

6842 "arrow-ipc",

6843 "arrow-schema",

6844 "async-trait",

6845 "bytes",

6846 "futures",

6847 "lance",

6848 "lance-core",

6849 "lance-index",

6850 "lance-io",

6851 "lance-linalg",

6852 "lance-namespace",

6853 "lance-table",

6854 "log 0.4.33",

6855 "object_store",

6856 "rand 0.9.5",

6857 "serde_json",

6858 "tokio",

6859 "url 2.5.8",

46656860]

46666861

46676862[[package]]

4668name = "jiff-static"

4669version = "0.2.35"

6863name = "lance-namespace-reqwest-client"

6864version = "0.7.7"

46706865source = "registry+https://github.com/rust-lang/crates.io-index"

4671checksum = "3a69dcb3a21cfb32ce1cd056169337ca284af0766dd766e7878819b251a49204"

6866checksum = "6369eee4682fb11edf538388b43c61ce288b8302fe89bb40944d7daa7faaae99"

46726867dependencies = [

4673 "jiff-core",

4674 "proc-macro2",

4675 "quote",

4676 "syn 2.0.119",

4677]

4678

4679[[package]]

4680name = "jiff-tzdb"

4681version = "0.1.8"

4682source = "registry+https://github.com/rust-lang/crates.io-index"

4683checksum = "142bd39932ad231f10513df9ab62661fead8719872150b7ad02a2df79f4e141e"

4684

4685[[package]]

4686name = "jiff-tzdb-platform"

4687version = "0.1.3"

4688source = "registry+https://github.com/rust-lang/crates.io-index"

4689checksum = "875a5a69ac2bab1a891711cf5eccbec1ce0341ea805560dcd90b7a2e925132e8"

4690dependencies = [

4691 "jiff-tzdb",

6868 "reqwest 0.12.28",

6869 "serde",

6870 "serde_json",

6871 "serde_repr",

6872 "serde_with",

6873 "url 2.5.8",

46926874]

46936875

46946876[[package]]

4695name = "jobserver"

4696version = "0.1.35"

6877name = "lance-table"

6878version = "7.0.0"

46976879source = "registry+https://github.com/rust-lang/crates.io-index"

4698checksum = "1c00acbd29eabad4a2392fa0e921c874934dbbf4194312ad20f04a0ed67a3cb3"

6880checksum = "b16f1355904aea4ebb04ffc70c58c97901e10bde44452b4b021de4a1f329250d"

46996881dependencies = [

4700 "getrandom 0.4.3",

4701 "libc",

6882 "arrow",

6883 "arrow-array",

6884 "arrow-buffer",

6885 "arrow-ipc",

6886 "arrow-schema",

6887 "async-trait",

6888 "byteorder",

6889 "bytes",

6890 "chrono",

6891 "deepsize",

6892 "futures",

6893 "lance-arrow",

6894 "lance-core",

6895 "lance-file",

6896 "lance-io",

6897 "log 0.4.33",

6898 "object_store",

6899 "prost",

6900 "prost-build",

6901 "prost-types",

6902 "rand 0.9.5",

6903 "rangemap",

6904 "roaring",

6905 "semver",

6906 "serde",

6907 "serde_json",

6908 "snafu 0.9.2",

6909 "tokio",

6910 "tracing",

6911 "url 2.5.8",

6912 "uuid",

47026913]

47036914

47046915[[package]]

4705name = "js-sys"

4706version = "0.3.104"

6916name = "lance-testing"

6917version = "7.0.0"

47076918source = "registry+https://github.com/rust-lang/crates.io-index"

4708checksum = "0e0c1080212aad755ea003d18543e8768dd432c48819efd73a7bf1e39b7a5a3a"

6919checksum = "3094c2aacbd1fa093d809fc54fa911e3498671ba451041341d7caaa18460e6b2"

47096920dependencies = [

4710 "cfg-if",

4711 "futures-util",

4712 "wasm-bindgen",

6921 "arrow-array",

6922 "arrow-schema",

6923 "lance-arrow",

6924 "num-traits",

6925 "rand 0.9.5",

47136926]

47146927

47156928[[package]]

4716name = "keccak"

4717version = "0.2.1"

6929name = "lance-tokenizer"

6930version = "7.0.0"

47186931source = "registry+https://github.com/rust-lang/crates.io-index"

4719checksum = "ffd9697dc4a9a62e2da93389f34400b77a28f0287711263cabb203b3ccb9c0e4"

6932checksum = "b39b7f5ed9d0c0b716bf599b559d888267ed1dfe4c4e29d3648b51d2a28940cf"

47206933dependencies = [

4721 "cfg-if",

4722 "cpufeatures 0.3.0",

6934 "jieba-rs",

6935 "lindera",

6936 "rust-stemmers",

6937 "serde",

6938 "unicode-normalization",

47236939]

47246940

47256941[[package]]

4726name = "kem"

4727version = "0.3.0"

6942name = "lancedb"

6943version = "0.30.0"

47286944source = "registry+https://github.com/rust-lang/crates.io-index"

4729checksum = "01737161ba802849cfd486b5bd209d38ba4943494c249a8126005170c7621edd"

6945checksum = "9db595d8da6c1fbf41ef6a547f27a73cc1105d83a837e8c76ce08743a3c09260"

47306946dependencies = [

4731 "crypto-common 0.2.2",

4732 "rand_core 0.10.1",

6947 "ahash 0.8.12",

6948 "arrow",

6949 "arrow-array",

6950 "arrow-cast",

6951 "arrow-data",

6952 "arrow-ipc",

6953 "arrow-ord",

6954 "arrow-schema",

6955 "arrow-select",

6956 "async-trait",

6957 "bytes",

6958 "chrono",

6959 "datafusion",

6960 "datafusion-catalog",

6961 "datafusion-common",

6962 "datafusion-execution",

6963 "datafusion-expr",

6964 "datafusion-functions",

6965 "datafusion-physical-expr",

6966 "datafusion-physical-plan",

6967 "datafusion-sql",

6968 "futures",

6969 "half",

6970 "lance",

6971 "lance-arrow",

6972 "lance-core",

6973 "lance-datafusion",

6974 "lance-datagen",

6975 "lance-encoding",

6976 "lance-file",

6977 "lance-index",

6978 "lance-io",

6979 "lance-linalg",

6980 "lance-namespace",

6981 "lance-namespace-impls",

6982 "lance-table",

6983 "lance-testing",

6984 "lazy_static",

6985 "log 0.4.33",

6986 "moka",

6987 "num-traits",

6988 "object_store",

6989 "pin-project",

6990 "rand 0.9.5",

6991 "regex",

6992 "semver",

6993 "serde",

6994 "serde_json",

6995 "serde_with",

6996 "snafu 0.8.9",

6997 "tempfile",

6998 "tokio",

6999 "url 2.5.8",

7000 "uuid",

47337001]

47347002

47357003[[package]]

@@ -4748,6 +7016,12 @@

47487016]

47497017

47507018[[package]]

7019name = "lebe"

7020version = "0.5.3"

7021source = "registry+https://github.com/rust-lang/crates.io-index"

7022checksum = "7a79a3332a6609480d7d0c9eab957bca6b455b91bb84e66d19f5ff66294b85b8"

7023

7024[[package]]

47517025name = "lettre"

47527026version = "0.11.23"

47537027source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -4763,7 +7037,7 @@

47637037 "httpdate",

47647038 "idna 1.1.0",

47657039 "mime 0.3.17",

4766 "nom",

7040 "nom 8.0.0",

47677041 "percent-encoding 2.3.2",

47687042 "quoted_printable",

47697043 "rustls",

@@ -4838,6 +7112,16 @@

48387112checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"

48397113

48407114[[package]]

7115name = "libfuzzer-sys"

7116version = "0.4.13"

7117source = "registry+https://github.com/rust-lang/crates.io-index"

7118checksum = "a9fd2f41a1cba099f79a0b6b6c35656cf7c03351a7bae8ff0f28f25270f929d2"

7119dependencies = [

7120 "arbitrary",

7121 "cc",

7122]

7123

7124[[package]]

48417125name = "libm"

48427126version = "0.2.16"

48437127source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -4863,6 +7147,60 @@

48637147]

48647148

48657149[[package]]

7150name = "lindera"

7151version = "3.0.7"

7152source = "registry+https://github.com/rust-lang/crates.io-index"

7153checksum = "74cda79d7161e99b414e4d292ff673cc3f8d22f070d8be3b6185c033363a9216"

7154dependencies = [

7155 "anyhow",

7156 "byteorder",

7157 "csv",

7158 "daachorse",

7159 "kanaria",

7160 "lindera-dictionary",

7161 "log 0.4.33",

7162 "once_cell",

7163 "percent-encoding 2.3.2",

7164 "regex",

7165 "serde",

7166 "serde_json",

7167 "serde_yaml_ng",

7168 "strum 0.28.0",

7169 "strum_macros 0.28.0",

7170 "unicode-blocks",

7171 "unicode-normalization",

7172 "unicode-segmentation",

7173 "url 2.5.8",

7174]

7175

7176[[package]]

7177name = "lindera-dictionary"

7178version = "3.0.7"

7179source = "registry+https://github.com/rust-lang/crates.io-index"

7180checksum = "e2385456ca9fe87c29072c5f156b52fdd5e28d5b5738ddfb3979501dbd736530"

7181dependencies = [

7182 "anyhow",

7183 "byteorder",

7184 "csv",

7185 "daachorse",

7186 "derive_builder",

7187 "encoding_rs",

7188 "encoding_rs_io",

7189 "glob",

7190 "log 0.4.33",

7191 "memmap2",

7192 "num_cpus",

7193 "once_cell",

7194 "regex",

7195 "rkyv 0.8.18",

7196 "serde",

7197 "serde_json",

7198 "strum 0.28.0",

7199 "strum_macros 0.28.0",

7200 "thiserror 2.0.20",

7201]

7202

7203[[package]]

48667204name = "linux-raw-sys"

48677205version = "0.12.1"

48687206source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -4899,6 +7237,28 @@

48997237checksum = "0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad"

49007238

49017239[[package]]

7240name = "loom"

7241version = "0.7.2"

7242source = "registry+https://github.com/rust-lang/crates.io-index"

7243checksum = "419e0dc8046cb947daa77eb95ae174acfbddb7673b4151f56d1eed8e93fbfaca"

7244dependencies = [

7245 "cfg-if",

7246 "generator",

7247 "scoped-tls",

7248 "tracing",

7249 "tracing-subscriber",

7250]

7251

7252[[package]]

7253name = "loop9"

7254version = "0.1.5"

7255source = "registry+https://github.com/rust-lang/crates.io-index"

7256checksum = "0fae87c125b03c1d2c0150c90365d7d6bcc53fb73a9acaef207d2d065860f062"

7257dependencies = [

7258 "imgref",

7259]

7260

7261[[package]]

49027262name = "lru-slab"

49037263version = "0.1.2"

49047264source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -4924,6 +7284,15 @@

49247284]

49257285

49267286[[package]]

7287name = "lz4_flex"

7288version = "0.13.1"

7289source = "registry+https://github.com/rust-lang/crates.io-index"

7290checksum = "7ef0d4ed8669f8f8826eb00dc878084aa8f253506c4fd5e8f58f5bce72ddb97e"

7291dependencies = [

7292 "twox-hash",

7293]

7294

7295[[package]]

49277296name = "mac_address"

49287297version = "1.1.8"

49297298source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -4935,6 +7304,22 @@

49357304]

49367305

49377306[[package]]

7307name = "macro_rules_attribute"

7308version = "0.2.3"

7309source = "registry+https://github.com/rust-lang/crates.io-index"

7310checksum = "b3ae8f6d608c795738406608304d30a2dfbdc8e58e44f7ba43236da5208ded3c"

7311dependencies = [

7312 "macro_rules_attribute-proc_macro",

7313 "pastey 0.2.3",

7314]

7315

7316[[package]]

7317name = "macro_rules_attribute-proc_macro"

7318version = "0.2.3"

7319source = "registry+https://github.com/rust-lang/crates.io-index"

7320checksum = "fc04a4c58212d57930a24bf47d3fa87485264a3a054e9c10e042eb373573ad3c"

7321

7322[[package]]

49387323name = "mails"

49397324version = "1.0.0"

49407325dependencies = [

@@ -4968,6 +7353,19 @@

49687353checksum = "47e1ffaa40ddd1f3ed91f717a33c8c0ee23fff369e3aa8772b9605cc1d22f4c3"

49697354

49707355[[package]]

7356name = "matrixmultiply"

7357version = "0.3.11"

7358source = "registry+https://github.com/rust-lang/crates.io-index"

7359checksum = "3f607c237553f086e7043417a51df26b2eb899d3caff94e6a67592ff992fedc7"

7360dependencies = [

7361 "autocfg",

7362 "num_cpus",

7363 "once_cell",

7364 "rawpointer",

7365 "thread-tree",

7366]

7367

7368[[package]]

49717369name = "maud"

49727370version = "0.27.0"

49737371source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -4992,6 +7390,26 @@

49927390]

49937391

49947392[[package]]

7393name = "maybe-rayon"

7394version = "0.1.1"

7395source = "registry+https://github.com/rust-lang/crates.io-index"

7396checksum = "8ea1f30cedd69f0a2954655f7188c6a834246d2bcf1e315e2ac40c4b24dc9519"

7397dependencies = [

7398 "cfg-if",

7399 "rayon",

7400]

7401

7402[[package]]

7403name = "md-5"

7404version = "0.10.6"

7405source = "registry+https://github.com/rust-lang/crates.io-index"

7406checksum = "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf"

7407dependencies = [

7408 "cfg-if",

7409 "digest 0.10.7",

7410]

7411

7412[[package]]

49957413name = "md-5"

49967414version = "0.11.0"

49977415source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -5095,6 +7513,12 @@

50957513]

50967514

50977515[[package]]

7516name = "minimal-lexical"

7517version = "0.2.1"

7518source = "registry+https://github.com/rust-lang/crates.io-index"

7519checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"

7520

7521[[package]]

50987522name = "miniz_oxide"

50997523version = "0.8.9"

51007524source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -5184,6 +7608,38 @@

51847608]

51857609

51867610[[package]]

7611name = "monostate"

7612version = "0.1.18"

7613source = "registry+https://github.com/rust-lang/crates.io-index"

7614checksum = "3341a273f6c9d5bef1908f17b7267bbab0e95c9bf69a0d4dcf8e9e1b2c76ef67"

7615dependencies = [

7616 "monostate-impl",

7617 "serde",

7618 "serde_core",

7619]

7620

7621[[package]]

7622name = "monostate-impl"

7623version = "0.1.18"

7624source = "registry+https://github.com/rust-lang/crates.io-index"

7625checksum = "e4db6d5580af57bf992f59068d4ea26fd518574ff48d7639b255a36f9de6e7e9"

7626dependencies = [

7627 "proc-macro2",

7628 "quote",

7629 "syn 2.0.119",

7630]

7631

7632[[package]]

7633name = "moxcms"

7634version = "0.8.1"

7635source = "registry+https://github.com/rust-lang/crates.io-index"

7636checksum = "bb85c154ba489f01b25c0d36ae69a87e4a1c73a72631fc6c0eb6dde34a73e44b"

7637dependencies = [

7638 "num-traits",

7639 "pxfm",

7640]

7641

7642[[package]]

51877643name = "multer"

51887644version = "3.1.0"

51897645source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -5201,6 +7657,32 @@

52017657]

52027658

52037659[[package]]

7660name = "multimap"

7661version = "0.10.1"

7662source = "registry+https://github.com/rust-lang/crates.io-index"

7663checksum = "1d87ecb2933e8aeadb3e3a02b828fed80a7528047e68b4f424523a0981a3a084"

7664

7665[[package]]

7666name = "munge"

7667version = "0.4.7"

7668source = "registry+https://github.com/rust-lang/crates.io-index"

7669checksum = "5e17401f259eba956ca16491461b6e8f72913a0a114e39736ce404410f915a0c"

7670dependencies = [

7671 "munge_macro",

7672]

7673

7674[[package]]

7675name = "munge_macro"

7676version = "0.4.7"

7677source = "registry+https://github.com/rust-lang/crates.io-index"

7678checksum = "4568f25ccbd45ab5d5603dc34318c1ec56b117531781260002151b8530a9f931"

7679dependencies = [

7680 "proc-macro2",

7681 "quote",

7682 "syn 2.0.119",

7683]

7684

7685[[package]]

52047686name = "native-tls"

52057687version = "0.2.18"

52067688source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -5218,6 +7700,27 @@

52187700]

52197701

52207702[[package]]

7703name = "ndarray"

7704version = "0.16.1"

7705source = "registry+https://github.com/rust-lang/crates.io-index"

7706checksum = "882ed72dce9365842bf196bdeedf5055305f11fc8c03dee7bb0194a6cad34841"

7707dependencies = [

7708 "matrixmultiply",

7709 "num-complex",

7710 "num-integer",

7711 "num-traits",

7712 "portable-atomic",

7713 "portable-atomic-util",

7714 "rawpointer",

7715]

7716

7717[[package]]

7718name = "new_debug_unreachable"

7719version = "1.0.6"

7720source = "registry+https://github.com/rust-lang/crates.io-index"

7721checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"

7722

7723[[package]]

52217724name = "nix"

52227725version = "0.29.0"

52237726source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -5243,6 +7746,25 @@

52437746]

52447747

52457748[[package]]

7749name = "no_std_io2"

7750version = "0.9.4"

7751source = "registry+https://github.com/rust-lang/crates.io-index"

7752checksum = "418abd1b6d34fbf6cae440dc874771b0525a604428704c76e48b29a5e67b8003"

7753dependencies = [

7754 "memchr",

7755]

7756

7757[[package]]

7758name = "nom"

7759version = "7.1.3"

7760source = "registry+https://github.com/rust-lang/crates.io-index"

7761checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"

7762dependencies = [

7763 "memchr",

7764 "minimal-lexical",

7765]

7766

7767[[package]]

52467768name = "nom"

52477769version = "8.0.0"

52487770source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -5263,8 +7785,14 @@

52637785source = "registry+https://github.com/rust-lang/crates.io-index"

52647786checksum = "9737e026353e5cd0736f98eddae28665118eb6f6600902a7f50db585621fecb6"

52657787dependencies = [

5266 "serde",

5267]

7788 "serde",

7789]

7790

7791[[package]]

7792name = "noop_proc_macro"

7793version = "0.3.0"

7794source = "registry+https://github.com/rust-lang/crates.io-index"

7795checksum = "0676bb32a98c1a483ce53e500a81ad9c3d5b3f7c920c28c24e9cb0980d0b5bc8"

52687796

52697797[[package]]

52707798name = "nu-ansi-term"

@@ -5317,6 +7845,7 @@

53177845source = "registry+https://github.com/rust-lang/crates.io-index"

53187846checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"

53197847dependencies = [

7848 "bytemuck",

53207849 "num-traits",

53217850]

53227851

@@ -5327,6 +7856,17 @@

53277856checksum = "521739c6d2bac4aa25192232afe6841231376b2b26d4d9fae5ecf8ca5772e441"

53287857

53297858[[package]]

7859name = "num-derive"

7860version = "0.4.2"

7861source = "registry+https://github.com/rust-lang/crates.io-index"

7862checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202"

7863dependencies = [

7864 "proc-macro2",

7865 "quote",

7866 "syn 2.0.119",

7867]

7868

7869[[package]]

53307870name = "num-integer"

53317871version = "0.1.47"

53327872source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -5392,6 +7932,12 @@

53927932]

53937933

53947934[[package]]

7935name = "number_prefix"

7936version = "0.4.0"

7937source = "registry+https://github.com/rust-lang/crates.io-index"

7938checksum = "830b246a0e5f20af87141b25c173cd1b609bd7779a4617d6ec582abaf90870f3"

7939

7940[[package]]

53957941name = "object"

53967942version = "0.39.1"

53977943source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -5401,12 +7947,60 @@

54017947]

54027948

54037949[[package]]

7950name = "object_store"

7951version = "0.13.2"

7952source = "registry+https://github.com/rust-lang/crates.io-index"

7953checksum = "622acbc9100d3c10e2ee15804b0caa40e55c933d5aa53814cd520805b7958a49"

7954dependencies = [

7955 "async-trait",

7956 "bytes",

7957 "chrono",

7958 "futures-channel",

7959 "futures-core",

7960 "futures-util",

7961 "http 1.5.0",

7962 "humantime",

7963 "itertools 0.14.0",

7964 "parking_lot",

7965 "percent-encoding 2.3.2",

7966 "thiserror 2.0.20",

7967 "tokio",

7968 "tracing",

7969 "url 2.5.8",

7970 "walkdir",

7971 "wasm-bindgen-futures",

7972 "web-time",

7973]

7974

7975[[package]]

54047976name = "once_cell"

54057977version = "1.21.4"

54067978source = "registry+https://github.com/rust-lang/crates.io-index"

54077979checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"

54087980

54097981[[package]]

7982name = "onig"

7983version = "6.5.3"

7984source = "registry+https://github.com/rust-lang/crates.io-index"

7985checksum = "0cc3cbf698f9438986c11a880c90a6d04b9de27575afd28bbf45b154b6c709e2"

7986dependencies = [

7987 "bitflags 2.13.1",

7988 "libc",

7989 "once_cell",

7990 "onig_sys",

7991]

7992

7993[[package]]

7994name = "onig_sys"

7995version = "69.9.3"

7996source = "registry+https://github.com/rust-lang/crates.io-index"

7997checksum = "1e68317604e77e53b85896388e1a803c1d21b74c899ec9e5e1112db90735edd7"

7998dependencies = [

7999 "cc",

8000 "pkg-config",

8001]

8002

8003[[package]]

54108004name = "opaque-debug"

54118005version = "0.3.1"

54128006source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -5557,6 +8151,15 @@

55578151]

55588152

55598153[[package]]

8154name = "ordered-float"

8155version = "5.5.0"

8156source = "registry+https://github.com/rust-lang/crates.io-index"

8157checksum = "8c7c9e0d9b23589f26070720bac724174bfec1083e82f7854cdd0267518343c0"

8158dependencies = [

8159 "num-traits",

8160]

8161

8162[[package]]

55608163name = "ordered-multimap"

55618164version = "0.4.3"

55628165source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -5567,6 +8170,26 @@

55678170]

55688171

55698172[[package]]

8173name = "ort"

8174version = "2.0.0-rc.9"

8175source = "registry+https://github.com/rust-lang/crates.io-index"

8176checksum = "52afb44b6b0cffa9bf45e4d37e5a4935b0334a51570658e279e9e3e6cf324aa5"

8177dependencies = [

8178 "ndarray",

8179 "ort-sys",

8180 "tracing",

8181]

8182

8183[[package]]

8184name = "ort-sys"

8185version = "2.0.0-rc.9"

8186source = "registry+https://github.com/rust-lang/crates.io-index"

8187checksum = "c41d7757331aef2d04b9cb09b45583a59217628beaf91895b7e76187b6e8c088"

8188dependencies = [

8189 "pkg-config",

8190]

8191

8192[[package]]

55708193name = "ouroboros"

55718194version = "0.18.5"

55728195source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -5757,6 +8380,30 @@

57578380checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"

57588381

57598382[[package]]

8383name = "pastey"

8384version = "0.1.1"

8385source = "registry+https://github.com/rust-lang/crates.io-index"

8386checksum = "35fb2e5f958ec131621fdd531e9fc186ed768cbe395337403ae56c17a74c68ec"

8387

8388[[package]]

8389name = "pastey"

8390version = "0.2.3"

8391source = "registry+https://github.com/rust-lang/crates.io-index"

8392checksum = "2ee67f1008b1ba2321834326597b8e186293b049a023cdef258527550b9935b4"

8393

8394[[package]]

8395name = "path_abs"

8396version = "0.5.1"

8397source = "registry+https://github.com/rust-lang/crates.io-index"

8398checksum = "05ef02f6342ac01d8a93b65f96db53fe68a92a15f41144f97fb00a9e669633c3"

8399dependencies = [

8400 "serde",

8401 "serde_derive",

8402 "std_prelude",

8403 "stfu8",

8404]

8405

8406[[package]]

57608407name = "pbkdf2"

57618408version = "0.13.0"

57628409source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -5820,6 +8467,12 @@

58208467checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"

58218468

58228469[[package]]

8470name = "permutation"

8471version = "0.4.1"

8472source = "registry+https://github.com/rust-lang/crates.io-index"

8473checksum = "df202b0b0f5b8e389955afd5f27b007b00fb948162953f1db9c70d2c7e3157d7"

8474

8475[[package]]

58238476name = "pest"

58248477version = "2.9.0"

58258478source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -5862,6 +8515,18 @@

58628515]

58638516

58648517[[package]]

8518name = "petgraph"

8519version = "0.8.3"

8520source = "registry+https://github.com/rust-lang/crates.io-index"

8521checksum = "8701b58ea97060d5e5b155d383a69952a60943f0e6dfe30b04c287beb0b27455"

8522dependencies = [

8523 "fixedbitset",

8524 "hashbrown 0.15.5",

8525 "indexmap 2.14.0",

8526 "serde",

8527]

8528

8529[[package]]

58658530name = "pgvector"

58668531version = "0.4.2"

58678532source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -5882,6 +8547,63 @@

58828547]

58838548

58848549[[package]]

8550name = "phf"

8551version = "0.12.1"

8552source = "registry+https://github.com/rust-lang/crates.io-index"

8553checksum = "913273894cec178f401a31ec4b656318d95473527be05c0752cc41cdc32be8b7"

8554dependencies = [

8555 "phf_shared 0.12.1",

8556]

8557

8558[[package]]

8559name = "phf"

8560version = "0.13.1"

8561source = "registry+https://github.com/rust-lang/crates.io-index"

8562checksum = "c1562dc717473dbaa4c1f85a36410e03c047b2e7df7f45ee938fbef64ae7fadf"

8563dependencies = [

8564 "phf_shared 0.13.1",

8565 "serde",

8566]

8567

8568[[package]]

8569name = "phf_codegen"

8570version = "0.13.1"

8571source = "registry+https://github.com/rust-lang/crates.io-index"

8572checksum = "49aa7f9d80421bca176ca8dbfebe668cc7a2684708594ec9f3c0db0805d5d6e1"

8573dependencies = [

8574 "phf_generator",

8575 "phf_shared 0.13.1",

8576]

8577

8578[[package]]

8579name = "phf_generator"

8580version = "0.13.1"

8581source = "registry+https://github.com/rust-lang/crates.io-index"

8582checksum = "135ace3a761e564ec88c03a77317a7c6b80bb7f7135ef2544dbe054243b89737"

8583dependencies = [

8584 "fastrand",

8585 "phf_shared 0.13.1",

8586]

8587

8588[[package]]

8589name = "phf_shared"

8590version = "0.12.1"

8591source = "registry+https://github.com/rust-lang/crates.io-index"

8592checksum = "06005508882fb681fd97892ecff4b7fd0fee13ef1aa569f8695dae7ab9099981"

8593dependencies = [

8594 "siphasher",

8595]

8596

8597[[package]]

8598name = "phf_shared"

8599version = "0.13.1"

8600source = "registry+https://github.com/rust-lang/crates.io-index"

8601checksum = "e57fef6bc5981e38c2ce2d63bfa546861309f875b8a75f092d1d54ae2d64f266"

8602dependencies = [

8603 "siphasher",

8604]

8605

8606[[package]]

58858607name = "pin-project"

58868608version = "1.1.13"

58878609source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -5984,6 +8706,19 @@

59848706]

59858707

59868708[[package]]

8709name = "png"

8710version = "0.18.1"

8711source = "registry+https://github.com/rust-lang/crates.io-index"

8712checksum = "60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61"

8713dependencies = [

8714 "bitflags 2.13.1",

8715 "crc32fast",

8716 "fdeflate",

8717 "flate2",

8718 "miniz_oxide",

8719]

8720

8721[[package]]

59878722name = "polling"

59888723version = "3.11.0"

59898724source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -6082,6 +8817,16 @@

60828817]

60838818

60848819[[package]]

8820name = "prettyplease"

8821version = "0.2.37"

8822source = "registry+https://github.com/rust-lang/crates.io-index"

8823checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"

8824dependencies = [

8825 "proc-macro2",

8826 "syn 2.0.119",

8827]

8828

8829[[package]]

60858830name = "primefield"

60868831version = "0.14.0"

60878832source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -6160,6 +8905,25 @@

61608905]

61618906

61628907[[package]]

8908name = "profiling"

8909version = "1.0.18"

8910source = "registry+https://github.com/rust-lang/crates.io-index"

8911checksum = "3d595e54a326bc53c1c197b32d295e14b169e3cfeaa8dc82b529f947fba6bcf5"

8912dependencies = [

8913 "profiling-procmacros",

8914]

8915

8916[[package]]

8917name = "profiling-procmacros"

8918version = "1.0.18"

8919source = "registry+https://github.com/rust-lang/crates.io-index"

8920checksum = "4488a4a36b9a4ba6b9334a32a39971f77c1436ec82c38707bce707699cc3bbcb"

8921dependencies = [

8922 "quote",

8923 "syn 2.0.119",

8924]

8925

8926[[package]]

61638927name = "prost"

61648928version = "0.14.4"

61658929source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -6170,6 +8934,25 @@

61708934]

61718935

61728936[[package]]

8937name = "prost-build"

8938version = "0.14.4"

8939source = "registry+https://github.com/rust-lang/crates.io-index"

8940checksum = "03da047801ff44bb6a4d407d4860c05fd70bb81714e6b2f3812603d5b145b042"

8941dependencies = [

8942 "heck 0.5.0",

8943 "itertools 0.14.0",

8944 "log 0.4.33",

8945 "multimap",

8946 "petgraph",

8947 "prettyplease",

8948 "prost",

8949 "prost-types",

8950 "regex",

8951 "syn 2.0.119",

8952 "tempfile",

8953]

8954

8955[[package]]

61738956name = "prost-derive"

61748957version = "0.14.4"

61758958source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -6183,6 +8966,15 @@

61838966]

61848967

61858968[[package]]

8969name = "prost-types"

8970version = "0.14.4"

8971source = "registry+https://github.com/rust-lang/crates.io-index"

8972checksum = "f94967dc7688f3054c7fac87473ffae4cc4c3904800e2d9f5b857246d8963b0a"

8973dependencies = [

8974 "prost",

8975]

8976

8977[[package]]

61868978name = "psm"

61878979version = "0.1.32"

61888980source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -6198,7 +8990,16 @@

61988990source = "registry+https://github.com/rust-lang/crates.io-index"

61998991checksum = "0738ccf7ea06b608c10564b31debd4f5bc5e197fc8bfe088f68ae5ce81e7a4f1"

62008992dependencies = [

6201 "ptr_meta_derive",

8993 "ptr_meta_derive 0.1.4",

8994]

8995

8996[[package]]

8997name = "ptr_meta"

8998version = "0.3.2"

8999source = "registry+https://github.com/rust-lang/crates.io-index"

9000checksum = "743da816b98c921cdbe8628ef7381b76f25ecf4da599fc80aca90eae7ef70cc0"

9001dependencies = [

9002 "ptr_meta_derive 0.3.2",

62029003]

62039004

62049005[[package]]

@@ -6213,6 +9014,17 @@

62139014]

62149015

62159016[[package]]

9017name = "ptr_meta_derive"

9018version = "0.3.2"

9019source = "registry+https://github.com/rust-lang/crates.io-index"

9020checksum = "1c8d9ca532f185d5d4db7a7c9d51420b452168ea1c2b913953281bd6fe1fcbd0"

9021dependencies = [

9022 "proc-macro2",

9023 "quote",

9024 "syn 3.0.3",

9025]

9026

9027[[package]]

62169028name = "pulldown-cmark"

62179029version = "0.13.4"

62189030source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -6228,29 +9040,73 @@

62289040name = "pulldown-cmark-escape"

62299041version = "0.11.0"

62309042source = "registry+https://github.com/rust-lang/crates.io-index"

6231checksum = "007d8adb5ddab6f8e3f491ac63566a7d5002cc7ed73901f72057943fa71ae1ae"

9043checksum = "007d8adb5ddab6f8e3f491ac63566a7d5002cc7ed73901f72057943fa71ae1ae"

9044

9045[[package]]

9046name = "pulls"

9047version = "1.0.0"

9048dependencies = [

9049 "axum",

9050 "config",

9051 "export",

9052 "git",

9053 "globset",

9054 "issues",

9055 "models",

9056 "sea-orm",

9057 "serde",

9058 "serde_json",

9059 "session",

9060 "space",

9061 "time 0.3.55",

9062 "tracing",

9063 "utoipa",

9064 "uuid",

9065]

9066

9067[[package]]

9068name = "pulp"

9069version = "0.22.3"

9070source = "registry+https://github.com/rust-lang/crates.io-index"

9071checksum = "046aa45b989642ec2e4717c8e72d677b13edd831a4d3b6cf37d9a3e54912496a"

9072dependencies = [

9073 "bytemuck",

9074 "cfg-if",

9075 "libm",

9076 "num-complex",

9077 "paste",

9078 "pulp-wasm-simd-flag",

9079 "raw-cpuid",

9080 "reborrow",

9081 "version_check 0.9.5",

9082]

9083

9084[[package]]

9085name = "pulp-wasm-simd-flag"

9086version = "0.1.1"

9087source = "registry+https://github.com/rust-lang/crates.io-index"

9088checksum = "1d8f70e07b9c3962945a74e59ca1c511bba65b6419468acc217c457d93f3c740"

9089

9090[[package]]

9091name = "pxfm"

9092version = "0.1.30"

9093source = "registry+https://github.com/rust-lang/crates.io-index"

9094checksum = "d55d956fa96f5ec02be2e13af0e20391a5aa83d6a074e3ad368959d0fab299ea"

9095

9096[[package]]

9097name = "qoi"

9098version = "0.4.1"

9099source = "registry+https://github.com/rust-lang/crates.io-index"

9100checksum = "7f6d64c71eb498fe9eae14ce4ec935c555749aef511cca85b5568910d6e48001"

9101dependencies = [

9102 "bytemuck",

9103]

62329104

62339105[[package]]

6234name = "pulls"

6235version = "1.0.0"

6236dependencies = [

6237 "axum",

6238 "config",

6239 "export",

6240 "git",

6241 "globset",

6242 "issues",

6243 "models",

6244 "sea-orm",

6245 "serde",

6246 "serde_json",

6247 "session",

6248 "space",

6249 "time 0.3.55",

6250 "tracing",

6251 "utoipa",

6252 "uuid",

6253]

9106name = "quick-error"

9107version = "2.0.1"

9108source = "registry+https://github.com/rust-lang/crates.io-index"

9109checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"

62549110

62559111[[package]]

62569112name = "quick-xml"

@@ -6288,6 +9144,7 @@

62889144source = "registry+https://github.com/rust-lang/crates.io-index"

62899145checksum = "04759210543be93709136e28212294a659ef5001836ff4eab4d663e4529bba83"

62909146dependencies = [

9147 "aws-lc-rs",

62919148 "bytes",

62929149 "getrandom 0.4.3",

62939150 "lru-slab",

@@ -6352,6 +9209,15 @@

63529209checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"

63539210

63549211[[package]]

9212name = "rancor"

9213version = "0.1.3"

9214source = "registry+https://github.com/rust-lang/crates.io-index"

9215checksum = "9b534442d0fcdb55d66f373d9cac6d33b6293a2335bc2136dbd06ce0e87d2572"

9216dependencies = [

9217 "ptr_meta 0.3.2",

9218]

9219

9220[[package]]

63559221name = "rand"

63569222version = "0.7.3"

63579223source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -6460,6 +9326,16 @@

64609326checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"

64619327

64629328[[package]]

9329name = "rand_distr"

9330version = "0.5.1"

9331source = "registry+https://github.com/rust-lang/crates.io-index"

9332checksum = "6a8615d50dcf34fa31f7ab52692afec947c4dd0ab803cc87cb3b0b4570ff7463"

9333dependencies = [

9334 "num-traits",

9335 "rand 0.9.5",

9336]

9337

9338[[package]]

64639339name = "rand_hc"

64649340version = "0.2.0"

64659341source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -6478,6 +9354,136 @@

64789354]

64799355

64809356[[package]]

9357name = "rand_xoshiro"

9358version = "0.7.0"

9359source = "registry+https://github.com/rust-lang/crates.io-index"

9360checksum = "f703f4665700daf5512dcca5f43afa6af89f09db47fb56be587f80636bda2d41"

9361dependencies = [

9362 "rand_core 0.9.5",

9363]

9364

9365[[package]]

9366name = "random_word"

9367version = "0.5.2"

9368source = "registry+https://github.com/rust-lang/crates.io-index"

9369checksum = "e47a395bdb55442b883c89062d6bcff25dc90fa5f8369af81e0ac6d49d78cf81"

9370dependencies = [

9371 "ahash 0.8.12",

9372 "brotli",

9373 "paste",

9374 "rand 0.9.5",

9375 "unicase 2.9.0",

9376]

9377

9378[[package]]

9379name = "rangemap"

9380version = "1.8.0"

9381source = "registry+https://github.com/rust-lang/crates.io-index"

9382checksum = "a611d15b50743feb4c76b7d03edcb0e64f399c26961e4efe6975bc398be6aa3d"

9383

9384[[package]]

9385name = "rav1e"

9386version = "0.8.1"

9387source = "registry+https://github.com/rust-lang/crates.io-index"

9388checksum = "43b6dd56e85d9483277cde964fd1bdb0428de4fec5ebba7540995639a21cb32b"

9389dependencies = [

9390 "aligned-vec",

9391 "arbitrary",

9392 "arg_enum_proc_macro",

9393 "arrayvec",

9394 "av-scenechange",

9395 "av1-grain",

9396 "bitstream-io",

9397 "built",

9398 "cfg-if",

9399 "interpolate_name",

9400 "itertools 0.14.0",

9401 "libc",

9402 "libfuzzer-sys",

9403 "log 0.4.33",

9404 "maybe-rayon",

9405 "new_debug_unreachable",

9406 "noop_proc_macro",

9407 "num-derive",

9408 "num-traits",

9409 "paste",

9410 "profiling",

9411 "rand 0.9.5",

9412 "rand_chacha 0.9.0",

9413 "simd_helpers",

9414 "thiserror 2.0.20",

9415 "v_frame",

9416 "wasm-bindgen",

9417]

9418

9419[[package]]

9420name = "ravif"

9421version = "0.13.0"

9422source = "registry+https://github.com/rust-lang/crates.io-index"

9423checksum = "e52310197d971b0f5be7fe6b57530dcd27beb35c1b013f29d66c1ad73fbbcc45"

9424dependencies = [

9425 "avif-serialize",

9426 "imgref",

9427 "loop9",

9428 "quick-error",

9429 "rav1e",

9430 "rayon",

9431 "rgb",

9432]

9433

9434[[package]]

9435name = "raw-cpuid"

9436version = "11.6.0"

9437source = "registry+https://github.com/rust-lang/crates.io-index"

9438checksum = "498cd0dc59d73224351ee52a95fee0f1a617a2eae0e7d9d720cc622c73a54186"

9439dependencies = [

9440 "bitflags 2.13.1",

9441]

9442

9443[[package]]

9444name = "rawpointer"

9445version = "0.2.1"

9446source = "registry+https://github.com/rust-lang/crates.io-index"

9447checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3"

9448

9449[[package]]

9450name = "rayon"

9451version = "1.12.0"

9452source = "registry+https://github.com/rust-lang/crates.io-index"

9453checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d"

9454dependencies = [

9455 "either",

9456 "rayon-core",

9457]

9458

9459[[package]]

9460name = "rayon-cond"

9461version = "0.4.0"

9462source = "registry+https://github.com/rust-lang/crates.io-index"

9463checksum = "2964d0cf57a3e7a06e8183d14a8b527195c706b7983549cd5462d5aa3747438f"

9464dependencies = [

9465 "either",

9466 "itertools 0.14.0",

9467 "rayon",

9468]

9469

9470[[package]]

9471name = "rayon-core"

9472version = "1.13.0"

9473source = "registry+https://github.com/rust-lang/crates.io-index"

9474checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"

9475dependencies = [

9476 "crossbeam-deque",

9477 "crossbeam-utils",

9478]

9479

9480[[package]]

9481name = "reborrow"

9482version = "0.5.5"

9483source = "registry+https://github.com/rust-lang/crates.io-index"

9484checksum = "03251193000f4bd3b042892be858ee50e8b3719f2b08e5833ac4353724632430"

9485

9486[[package]]

64819487name = "redis"

64829488version = "1.6.0"

64839489source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -6529,6 +9535,37 @@

65299535]

65309536

65319537[[package]]

9538name = "redox_users"

9539version = "0.5.2"

9540source = "registry+https://github.com/rust-lang/crates.io-index"

9541checksum = "a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac"

9542dependencies = [

9543 "getrandom 0.2.17",

9544 "libredox",

9545 "thiserror 2.0.20",

9546]

9547

9548[[package]]

9549name = "ref-cast"

9550version = "1.0.27"

9551source = "registry+https://github.com/rust-lang/crates.io-index"

9552checksum = "7e440fb4e4b4147295338efb76001ab9e4efc0e5839df2c47fc5ac2381d365c3"

9553dependencies = [

9554 "ref-cast-impl",

9555]

9556

9557[[package]]

9558name = "ref-cast-impl"

9559version = "1.0.27"

9560source = "registry+https://github.com/rust-lang/crates.io-index"

9561checksum = "92ecd8964f8453721699a1ed72037b0db49ce2f5a5138486ee89bed6f67cdf3a"

9562dependencies = [

9563 "proc-macro2",

9564 "quote",

9565 "syn 3.0.3",

9566]

9567

9568[[package]]

65329569name = "regex"

65339570version = "1.13.1"

65349571source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -6563,7 +9600,16 @@

65639600source = "registry+https://github.com/rust-lang/crates.io-index"

65649601checksum = "71fe3824f5629716b1589be05dacd749f6aa084c87e00e016714a8cdfccc997c"

65659602dependencies = [

6566 "bytecheck",

9603 "bytecheck 0.6.12",

9604]

9605

9606[[package]]

9607name = "rend"

9608version = "0.5.4"

9609source = "registry+https://github.com/rust-lang/crates.io-index"

9610checksum = "663ba70707f96e871406fe10d68128412e619b06d1d47cb91c3a4c6501176240"

9611dependencies = [

9612 "bytecheck 0.8.3",

65679613]

65689614

65699615[[package]]

@@ -6574,7 +9620,10 @@

65749620dependencies = [

65759621 "base64 0.22.1",

65769622 "bytes",

9623 "encoding_rs",

65779624 "futures-core",

9625 "futures-util",

9626 "h2 0.4.19",

65789627 "http 1.5.0",

65799628 "http-body 1.1.0",

65809629 "http-body-util",

@@ -6583,10 +9632,13 @@

65839632 "hyper-util",

65849633 "js-sys",

65859634 "log 0.4.33",

9635 "mime 0.3.17",

9636 "mime_guess",

65869637 "percent-encoding 2.3.2",

65879638 "pin-project-lite",

65889639 "quinn",

65899640 "rustls",

9641 "rustls-native-certs",

65909642 "rustls-pki-types",

65919643 "serde",

65929644 "serde_json",

@@ -6594,14 +9646,16 @@

65949646 "sync_wrapper",

65959647 "tokio",

65969648 "tokio-rustls",

9649 "tokio-util",

65979650 "tower",

65989651 "tower-http 0.6.11",

65999652 "tower-service",

66009653 "url 2.5.8",

66019654 "wasm-bindgen",

66029655 "wasm-bindgen-futures",

9656 "wasm-streams 0.4.2",

66039657 "web-sys",

6604 "webpki-roots",

9658 "webpki-roots 1.0.9",

66059659]

66069660

66079661[[package]]

@@ -6612,47 +9666,207 @@

66129666dependencies = [

66139667 "base64 0.22.1",

66149668 "bytes",

9669 "encoding_rs",

66159670 "futures-channel",

66169671 "futures-core",

66179672 "futures-util",

9673 "h2 0.4.19",

66189674 "http 1.5.0",

66199675 "http-body 1.1.0",

66209676 "http-body-util",

66219677 "hyper 1.11.0",

9678 "hyper-rustls",

66229679 "hyper-util",

66239680 "js-sys",

66249681 "log 0.4.33",

9682 "mime 0.3.17",

9683 "mime_guess",

66259684 "percent-encoding 2.3.2",

66269685 "pin-project-lite",

9686 "quinn",

9687 "rustls",

9688 "rustls-pki-types",

9689 "rustls-platform-verifier",

9690 "serde",

9691 "serde_json",

9692 "serde_urlencoded",

66279693 "sync_wrapper",

66289694 "tokio",

9695 "tokio-rustls",

9696 "tokio-util",

66299697 "tower",

66309698 "tower-http 0.6.11",

66319699 "tower-service",

66329700 "url 2.5.8",

66339701 "wasm-bindgen",

66349702 "wasm-bindgen-futures",

9703 "wasm-streams 0.5.0",

66359704 "web-sys",

66369705]

66379706

66389707[[package]]

66399708name = "rfc6979"

6640version = "0.4.0"

9709version = "0.4.0"

9710source = "registry+https://github.com/rust-lang/crates.io-index"

9711checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2"

9712dependencies = [

9713 "hmac 0.12.1",

9714 "subtle",

9715]

9716

9717[[package]]

9718name = "rfc6979"

9719version = "0.6.0"

9720source = "registry+https://github.com/rust-lang/crates.io-index"

9721checksum = "b4a459cddafb3fe76b31fd8f1108007566c40301feb64dc7b54656eb7388172b"

9722dependencies = [

9723 "crypto-bigint 0.7.5",

9724 "hmac 0.13.0",

9725]

9726

9727[[package]]

9728name = "rgb"

9729version = "0.8.53"

9730source = "registry+https://github.com/rust-lang/crates.io-index"

9731checksum = "47b34b781b31e5d73e9fbc8689c70551fd1ade9a19e3e28cfec8580a79290cc4"

9732

9733[[package]]

9734name = "rig"

9735version = "0.42.0"

9736source = "registry+https://github.com/rust-lang/crates.io-index"

9737checksum = "b989f4060e5f3c1ea4b8b6999f6759949d820704286cc6976b7a688cc0133029"

9738dependencies = [

9739 "rig-agent",

9740 "rig-core",

9741 "rig-derive",

9742 "rig-fastembed",

9743 "rig-helixdb",

9744 "rig-lancedb",

9745 "rig-milvus",

9746]

9747

9748[[package]]

9749name = "rig-agent"

9750version = "0.42.0"

9751source = "registry+https://github.com/rust-lang/crates.io-index"

9752checksum = "b66477c0d0a786358d078e7e3541a73089dd9009100d6e2b3fe3b0d730e8550f"

9753dependencies = [

9754 "async-stream",

9755 "fastrand",

9756 "futures",

9757 "http 1.5.0",

9758 "indexmap 2.14.0",

9759 "rig-core",

9760 "rig-derive",

9761 "schemars 1.2.2",

9762 "serde",

9763 "serde_json",

9764 "thiserror 2.0.20",

9765 "tokio",

9766 "tracing",

9767 "tracing-futures",

9768]

9769

9770[[package]]

9771name = "rig-core"

9772version = "0.42.0"

9773source = "registry+https://github.com/rust-lang/crates.io-index"

9774checksum = "432d83e0facf16749f91fe729cbffca84437e8062d2f4e92f4f12e903693922d"

9775dependencies = [

9776 "as-any",

9777 "async-stream",

9778 "base64 0.22.1",

9779 "bytes",

9780 "eventsource-stream",

9781 "fastrand",

9782 "futures",

9783 "futures-timer",

9784 "glob",

9785 "http 1.5.0",

9786 "indexmap 2.14.0",

9787 "mime 0.3.17",

9788 "mime_guess",

9789 "ordered-float 5.5.0",

9790 "pin-project-lite",

9791 "reqwest 0.13.4",

9792 "rig-derive",

9793 "schemars 1.2.2",

9794 "serde",

9795 "serde_json",

9796 "sha2 0.10.9",

9797 "thiserror 2.0.20",

9798 "tokio",

9799 "tokio-tungstenite",

9800 "tracing",

9801 "tracing-futures",

9802 "url 2.5.8",

9803]

9804

9805[[package]]

9806name = "rig-derive"

9807version = "0.42.0"

9808source = "registry+https://github.com/rust-lang/crates.io-index"

9809checksum = "de0a33f1bac45f16e50146c248bcbbfaa44518c7252d274e972c7f4ad71aaba7"

9810dependencies = [

9811 "convert_case",

9812 "proc-macro-crate",

9813 "proc-macro2",

9814 "quote",

9815 "syn 2.0.119",

9816]

9817

9818[[package]]

9819name = "rig-fastembed"

9820version = "0.42.0"

9821source = "registry+https://github.com/rust-lang/crates.io-index"

9822checksum = "f1dff99f9bea13108bb14df5431b6fc0738beb87f1fe5ebfcf26ae9fe54a188d"

9823dependencies = [

9824 "fastembed",

9825 "rig-core",

9826 "schemars 1.2.2",

9827 "serde",

9828 "serde_json",

9829 "tracing",

9830]

9831

9832[[package]]

9833name = "rig-helixdb"

9834version = "0.42.0"

9835source = "registry+https://github.com/rust-lang/crates.io-index"

9836checksum = "b5fa2b188a1e9e65d29c34738c97465f0822c57540d6d45fd4f04dad906c966a"

9837dependencies = [

9838 "reqwest 0.13.4",

9839 "rig-core",

9840 "serde",

9841 "serde_json",

9842 "thiserror 2.0.20",

9843]

9844

9845[[package]]

9846name = "rig-lancedb"

9847version = "0.42.0"

66419848source = "registry+https://github.com/rust-lang/crates.io-index"

6642checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2"

9849checksum = "c5fe3555202c5bd4e30948414c2e234fddd9260d4520046733fcf0d58718f3a1"

66439850dependencies = [

6644 "hmac 0.12.1",

6645 "subtle",

9851 "arrow-array",

9852 "futures",

9853 "lancedb",

9854 "rig-core",

9855 "serde",

9856 "serde_json",

66469857]

66479858

66489859[[package]]

6649name = "rfc6979"

6650version = "0.6.0"

9860name = "rig-milvus"

9861version = "0.42.0"

66519862source = "registry+https://github.com/rust-lang/crates.io-index"

6652checksum = "b4a459cddafb3fe76b31fd8f1108007566c40301feb64dc7b54656eb7388172b"

9863checksum = "af9c7b7ff7ed9c16da983a21f1e81f425c9805355427a92f4d2d97ba1fe2aa12"

66539864dependencies = [

6654 "crypto-bigint 0.7.5",

6655 "hmac 0.13.0",

9865 "reqwest 0.13.4",

9866 "rig-core",

9867 "serde",

9868 "serde_json",

9869 "uuid",

66569870]

66579871

66589872[[package]]

@@ -6676,18 +9890,37 @@

66769890checksum = "2297bf9c81a3f0dc96bc9521370b88f054168c29826a75e89c55ff196e7ed6a1"

66779891dependencies = [

66789892 "bitvec",

6679 "bytecheck",

9893 "bytecheck 0.6.12",

66809894 "bytes",

66819895 "hashbrown 0.12.3",

6682 "ptr_meta",

6683 "rend",

6684 "rkyv_derive",

9896 "ptr_meta 0.1.4",

9897 "rend 0.4.2",

9898 "rkyv_derive 0.7.46",

66859899 "seahash",

66869900 "tinyvec",

66879901 "uuid",

66889902]

66899903

66909904[[package]]

9905name = "rkyv"

9906version = "0.8.18"

9907source = "registry+https://github.com/rust-lang/crates.io-index"

9908checksum = "d9776093b7ca170454ab1406954f7b7d97a57c51dc6c0642957fb2ef25c2d399"

9909dependencies = [

9910 "bytecheck 0.8.3",

9911 "bytes",

9912 "hashbrown 0.17.1",

9913 "indexmap 2.14.0",

9914 "munge",

9915 "ptr_meta 0.3.2",

9916 "rancor",

9917 "rend 0.5.4",

9918 "rkyv_derive 0.8.18",

9919 "tinyvec",

9920 "uuid",

9921]

9922

9923[[package]]

66919924name = "rkyv_derive"

66929925version = "0.7.46"

66939926source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -6699,6 +9932,27 @@

66999932]

67009933

67019934[[package]]

9935name = "rkyv_derive"

9936version = "0.8.18"

9937source = "registry+https://github.com/rust-lang/crates.io-index"

9938checksum = "1c25ef604ac7dd839d44d64648952ea23c97866f124ff671b0ed2cf3ad9bb06e"

9939dependencies = [

9940 "proc-macro2",

9941 "quote",

9942 "syn 3.0.3",

9943]

9944

9945[[package]]

9946name = "roaring"

9947version = "0.11.5"

9948source = "registry+https://github.com/rust-lang/crates.io-index"

9949checksum = "18bd8a37d17a58532776dcdf6041ce64929adca78e8489d5cacbafe99229d3e1"

9950dependencies = [

9951 "bytemuck",

9952 "byteorder",

9953]

9954

9955[[package]]

67029956name = "rsa"

67039957version = "0.9.10"

67049958source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -6916,6 +10170,16 @@

691610170]

691710171

691810172[[package]]

10173name = "rust-stemmers"

10174version = "1.2.0"

10175source = "registry+https://github.com/rust-lang/crates.io-index"

10176checksum = "e46a2036019fdb888131db7a4c847a1063a7493f971ed94ea82c67eada63ca54"

10177dependencies = [

10178 "serde",

10179 "serde_derive",

10180]

10181

10182[[package]]

691910183name = "rust_decimal"

692010184version = "1.42.1"

692110185source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -6926,7 +10190,7 @@

692610190 "bytes",

692710191 "num-traits",

692810192 "rand 0.8.7",

6929 "rkyv",

10193 "rkyv 0.7.46",

693010194 "serde",

693110195 "serde_json",

693210196 "wasm-bindgen",

@@ -6966,6 +10230,7 @@

696610230source = "registry+https://github.com/rust-lang/crates.io-index"

696710231checksum = "0283386ce02abc0151e1761d08802dfe86c173b0b494af5cbc086574e453da06"

696810232dependencies = [

10233 "aws-lc-rs",

696910234 "log 0.4.33",

697010235 "once_cell",

697110236 "ring",

@@ -6998,11 +10263,39 @@

699810263]

699910264

700010265[[package]]

10266name = "rustls-platform-verifier"

10267version = "0.7.0"

10268source = "registry+https://github.com/rust-lang/crates.io-index"

10269checksum = "26d1e2536ce4f35f4846aa13bff16bd0ff40157cdb14cc056c7b14ba41233ba0"

10270dependencies = [

10271 "core-foundation 0.10.1",

10272 "core-foundation-sys",

10273 "jni",

10274 "log 0.4.33",

10275 "once_cell",

10276 "rustls",

10277 "rustls-native-certs",

10278 "rustls-platform-verifier-android",

10279 "rustls-webpki",

10280 "security-framework",

10281 "security-framework-sys",

10282 "webpki-root-certs",

10283 "windows-sys 0.61.2",

10284]

10285

10286[[package]]

10287name = "rustls-platform-verifier-android"

10288version = "0.1.1"

10289source = "registry+https://github.com/rust-lang/crates.io-index"

10290checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f"

10291

10292[[package]]

700110293name = "rustls-webpki"

700210294version = "0.103.14"

700310295source = "registry+https://github.com/rust-lang/crates.io-index"

700410296checksum = "0527518605e68109d875e248ea259b6758801cf165e4b2c2733ae3b51f12535a"

700510297dependencies = [

10298 "aws-lc-rs",

700610299 "ring",

700710300 "rustls-pki-types",

700810301 "untrusted 0.9.0",

@@ -7072,6 +10365,49 @@

707210365]

707310366

707410367[[package]]

10368name = "schemars"

10369version = "0.9.0"

10370source = "registry+https://github.com/rust-lang/crates.io-index"

10371checksum = "4cd191f9397d57d581cddd31014772520aa448f65ef991055d7f61582c65165f"

10372dependencies = [

10373 "dyn-clone",

10374 "ref-cast",

10375 "serde",

10376 "serde_json",

10377]

10378

10379[[package]]

10380name = "schemars"

10381version = "1.2.2"

10382source = "registry+https://github.com/rust-lang/crates.io-index"

10383checksum = "687274d293b6cdc6e73e0fee520bf2049650090d7164f87672d212a3c530cf4a"

10384dependencies = [

10385 "dyn-clone",

10386 "ref-cast",

10387 "schemars_derive",

10388 "serde",

10389 "serde_json",

10390]

10391

10392[[package]]

10393name = "schemars_derive"

10394version = "1.2.2"

10395source = "registry+https://github.com/rust-lang/crates.io-index"

10396checksum = "d98c67716b46af2f0b8cf752abc930f6f9aecfbf671ecfb531db8a31dbe4e2ba"

10397dependencies = [

10398 "proc-macro2",

10399 "quote",

10400 "serde_derive_internals",

10401 "syn 3.0.3",

10402]

10403

10404[[package]]

10405name = "scoped-tls"

10406version = "1.0.1"

10407source = "registry+https://github.com/rust-lang/crates.io-index"

10408checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"

10409

10410[[package]]

707510411name = "scopeguard"

707610412version = "1.2.0"

707710413source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -7173,7 +10509,7 @@

717310509checksum = "546040c653a705e60ec65ecd3191a809603734bebbc225775916dea9ae409b31"

717410510dependencies = [

717510511 "chrono",

7176 "ordered-float",

10512 "ordered-float 4.6.0",

717710513 "rust_decimal",

717810514 "sea-query-derive",

717910515 "serde_json",

@@ -7271,7 +10607,7 @@

727110607checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d"

727210608dependencies = [

727310609 "bitflags 2.13.1",

7274 "core-foundation",

10610 "core-foundation 0.10.1",

727510611 "core-foundation-sys",

727610612 "libc",

727710613 "security-framework-sys",

@@ -7294,6 +10630,18 @@

729410630checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"

729510631

729610632[[package]]

10633name = "send_wrapper"

10634version = "0.6.0"

10635source = "registry+https://github.com/rust-lang/crates.io-index"

10636checksum = "cd0b0ec5f1c1ca621c432a25813d8d60c88abe6d3e08a3eb9cf37d97a0fe3d73"

10637

10638[[package]]

10639name = "seq-macro"

10640version = "0.3.6"

10641source = "registry+https://github.com/rust-lang/crates.io-index"

10642checksum = "1bc711410fbe7399f390ca1c3b60ad0f53f80e95c5eb935e52268a0e2cd49acc"

10643

10644[[package]]

729710645name = "serde"

729810646version = "1.0.229"

729910647source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -7324,6 +10672,17 @@

732410672]

732510673

732610674[[package]]

10675name = "serde_derive_internals"

10676version = "0.30.0"

10677source = "registry+https://github.com/rust-lang/crates.io-index"

10678checksum = "f852137cce035d6a4df67ccce505ff6b3e9fd3a10e3e52b24dc71e650bb1a9bd"

10679dependencies = [

10680 "proc-macro2",

10681 "quote",

10682 "syn 3.0.3",

10683]

10684

10685[[package]]

732710686name = "serde_json"

732810687version = "1.0.151"

732910688source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -7348,6 +10707,17 @@

734810707]

734910708

735010709[[package]]

10710name = "serde_repr"

10711version = "0.1.21"

10712source = "registry+https://github.com/rust-lang/crates.io-index"

10713checksum = "8d3b1629de253c70a0508c3899572da79ca359fdab27c7920ff00406df418906"

10714dependencies = [

10715 "proc-macro2",

10716 "quote",

10717 "syn 3.0.3",

10718]

10719

10720[[package]]

735110721name = "serde_spanned"

735210722version = "0.6.9"

735310723source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -7380,6 +10750,52 @@

738010750]

738110751

738210752[[package]]

10753name = "serde_with"

10754version = "3.23.0"

10755source = "registry+https://github.com/rust-lang/crates.io-index"

10756checksum = "935177bb8c0cd8ca1a4e6d1a2ac8988bea69cab4f9d3a31311e012ad27868ea4"

10757dependencies = [

10758 "base64 0.23.1",

10759 "bs58",

10760 "chrono",

10761 "hex",

10762 "indexmap 1.9.3",

10763 "indexmap 2.14.0",

10764 "jiff",

10765 "schemars 0.9.0",

10766 "schemars 1.2.2",

10767 "serde_core",

10768 "serde_json",

10769 "serde_with_macros",

10770 "time 0.3.55",

10771]

10772

10773[[package]]

10774name = "serde_with_macros"

10775version = "3.23.0"

10776source = "registry+https://github.com/rust-lang/crates.io-index"

10777checksum = "1d607aa01a3cb0ad757d6fd216136910db3c97b102fe686585689615a02dbcdc"

10778dependencies = [

10779 "darling 0.24.1",

10780 "proc-macro2",

10781 "quote",

10782 "syn 3.0.3",

10783]

10784

10785[[package]]

10786name = "serde_yaml_ng"

10787version = "0.10.0"

10788source = "registry+https://github.com/rust-lang/crates.io-index"

10789checksum = "7b4db627b98b36d4203a7b458cf3573730f2bb591b28871d916dfa9efabfd41f"

10790dependencies = [

10791 "indexmap 2.14.0",

10792 "itoa",

10793 "ryu",

10794 "serde",

10795 "unsafe-libyaml",

10796]

10797

10798[[package]]

738310799name = "serdect"

738410800version = "0.4.3"

738510801source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -7557,12 +10973,37 @@

755710973checksum = "3a219298ac11a56ea9a6d2120044824d6f01aeb034955e7af7bc16858527deea"

755810974

755910975[[package]]

10976name = "simd_cesu8"

10977version = "1.2.0"

10978source = "registry+https://github.com/rust-lang/crates.io-index"

10979checksum = "11031e251abf8611c80f460e19dbdeb54a66db918e49c65a7065b46ac7aec520"

10980dependencies = [

10981 "rustc_version",

10982 "simdutf8",

10983]

10984

10985[[package]]

10986name = "simd_helpers"

10987version = "0.1.0"

10988source = "registry+https://github.com/rust-lang/crates.io-index"

10989checksum = "95890f873bec569a0362c235787f3aca6e1e887302ba4840839bcc6459c42da6"

10990dependencies = [

10991 "quote",

10992]

10993

10994[[package]]

756010995name = "simdutf8"

756110996version = "0.1.5"

756210997source = "registry+https://github.com/rust-lang/crates.io-index"

756310998checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e"

756410999

756511000[[package]]

11001name = "siphasher"

11002version = "1.0.3"

11003source = "registry+https://github.com/rust-lang/crates.io-index"

11004checksum = "8ee5873ec9cce0195efcb7a4e9507a04cd49aec9c83d0389df45b1ef7ba2e649"

11005

11006[[package]]

756611007name = "slab"

756711008version = "0.4.12"

756811009source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -7595,6 +11036,48 @@

759511036]

759611037

759711038[[package]]

11039name = "snafu"

11040version = "0.8.9"

11041source = "registry+https://github.com/rust-lang/crates.io-index"

11042checksum = "6e84b3f4eacbf3a1ce05eac6763b4d629d60cbc94d632e4092c54ade71f1e1a2"

11043dependencies = [

11044 "snafu-derive 0.8.9",

11045]

11046

11047[[package]]

11048name = "snafu"

11049version = "0.9.2"

11050source = "registry+https://github.com/rust-lang/crates.io-index"

11051checksum = "e45cb604038abb7b926b679887b3226d8d0f23874b66623625a0454be425a4b7"

11052dependencies = [

11053 "snafu-derive 0.9.2",

11054]

11055

11056[[package]]

11057name = "snafu-derive"

11058version = "0.8.9"

11059source = "registry+https://github.com/rust-lang/crates.io-index"

11060checksum = "c1c97747dbf44bb1ca44a561ece23508e99cb592e862f22222dcf42f51d1e451"

11061dependencies = [

11062 "heck 0.5.0",

11063 "proc-macro2",

11064 "quote",

11065 "syn 2.0.119",

11066]

11067

11068[[package]]

11069name = "snafu-derive"

11070version = "0.9.2"

11071source = "registry+https://github.com/rust-lang/crates.io-index"

11072checksum = "287f59010008f0d7cf5e3b03196d666c1acc46c8d3e9cf34c28a1a7157601e72"

11073dependencies = [

11074 "heck 0.5.0",

11075 "proc-macro2",

11076 "quote",

11077 "syn 2.0.119",

11078]

11079

11080[[package]]

759811081name = "socket2"

759911082version = "0.5.10"

760011083source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -7615,6 +11098,17 @@

761511098]

761611099

761711100[[package]]

11101name = "socks"

11102version = "0.3.4"

11103source = "registry+https://github.com/rust-lang/crates.io-index"

11104checksum = "f0c3dbbd9ae980613c6dd8e28a9407b50509d3803b57624d5dfe8315218cd58b"

11105dependencies = [

11106 "byteorder",

11107 "libc",

11108 "winapi",

11109]

11110

11111[[package]]

761811112name = "space"

761911113version = "1.0.0"

762011114dependencies = [

@@ -7667,12 +11161,45 @@

766711161]

766811162

766911163[[package]]

11164name = "spm_precompiled"

11165version = "0.1.4"

11166source = "registry+https://github.com/rust-lang/crates.io-index"

11167checksum = "5851699c4033c63636f7ea4cf7b7c1f1bf06d0cc03cfb42e711de5a5c46cf326"

11168dependencies = [

11169 "base64 0.13.1",

11170 "nom 7.1.3",

11171 "serde",

11172 "unicode-segmentation",

11173]

11174

11175[[package]]

767011176name = "sponge-cursor"

767111177version = "0.1.0"

767211178source = "registry+https://github.com/rust-lang/crates.io-index"

767311179checksum = "3a0219bd7d979d58245a4f41f695e1ac9f8befdffadd7f61f1bae9e39abc6620"

767411180

767511181[[package]]

11182name = "sqlparser"

11183version = "0.61.0"

11184source = "registry+https://github.com/rust-lang/crates.io-index"

11185checksum = "dbf5ea8d4d7c808e1af1cbabebca9a2abe603bcefc22294c5b95018d53200cb7"

11186dependencies = [

11187 "log 0.4.33",

11188 "sqlparser_derive",

11189]

11190

11191[[package]]

11192name = "sqlparser_derive"

11193version = "0.5.0"

11194source = "registry+https://github.com/rust-lang/crates.io-index"

11195checksum = "a6dd45d8fc1c79299bfbb7190e42ccbbdf6a5f52e4a6ad98d92357ea965bd289"

11196dependencies = [

11197 "proc-macro2",

11198 "quote",

11199 "syn 2.0.119",

11200]

11201

11202[[package]]

767611203name = "sqlx"

767711204version = "0.9.0"

767811205source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -7705,7 +11232,7 @@

770511232 "futures-util",

770611233 "hashbrown 0.16.1",

770711234 "hashlink",

7708 "indexmap",

11235 "indexmap 2.14.0",

770911236 "log 0.4.33",

771011237 "memchr",

771111238 "percent-encoding 2.3.2",

@@ -7722,7 +11249,7 @@

772211249 "tracing",

772311250 "url 2.5.8",

772411251 "uuid",

7725 "webpki-roots",

11252 "webpki-roots 1.0.9",

772611253]

772711254

772811255[[package]]

@@ -7815,7 +11342,7 @@

781511342 "hmac 0.13.0",

781611343 "itoa",

781711344 "log 0.4.33",

7818 "md-5",

11345 "md-5 0.11.0",

781911346 "memchr",

782011347 "rand 0.10.2",

782111348 "rust_decimal",

@@ -7991,6 +11518,18 @@

799111518checksum = "d7beae5182595e9a8b683fa98c4317f956c9a2dec3b9716990d20023cc60c766"

799211519

799311520[[package]]

11521name = "std_prelude"

11522version = "0.2.12"

11523source = "registry+https://github.com/rust-lang/crates.io-index"

11524checksum = "8207e78455ffdf55661170876f88daf85356e4edd54e0a3dbc79586ca1e50cbe"

11525

11526[[package]]

11527name = "stfu8"

11528version = "0.2.7"

11529source = "registry+https://github.com/rust-lang/crates.io-index"

11530checksum = "e51f1e89f093f99e7432c491c382b88a6860a5adbe6bf02574bf0a08efff1978"

11531

11532[[package]]

799411533name = "storage"

799511534version = "1.0.0"

799611535dependencies = [

@@ -8022,6 +11561,15 @@

802211561

802311562[[package]]

802411563name = "strum"

11564version = "0.26.3"

11565source = "registry+https://github.com/rust-lang/crates.io-index"

11566checksum = "8fec0f0aef304996cf250b31b5a10dee7980c85da9d759361292b8bca5a18f06"

11567dependencies = [

11568 "strum_macros 0.26.4",

11569]

11570

11571[[package]]

11572name = "strum"

802511573version = "0.27.2"

802611574source = "registry+https://github.com/rust-lang/crates.io-index"

802711575checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf"

@@ -8033,7 +11581,10 @@

803311581name = "strum"

803411582version = "0.28.0"

803511583source = "registry+https://github.com/rust-lang/crates.io-index"

8036checksum = "9628de9b8791db39ceda2b119bbe13134770b56c138ec1d3af810d045c04f9bd"

11584checksum = "9628de9b8791db39ceda2b119bbe13134770b56c138ec1d3af810d045c04f9bd"

11585dependencies = [

11586 "strum_macros 0.28.0",

11587]

803711588

803811589[[package]]

803911590name = "strum_macros"

@@ -8050,6 +11601,19 @@

805011601

805111602[[package]]

805211603name = "strum_macros"

11604version = "0.26.4"

11605source = "registry+https://github.com/rust-lang/crates.io-index"

11606checksum = "4c6bee85a5a24955dc440386795aa378cd9cf82acd5f764469152d2270e581be"

11607dependencies = [

11608 "heck 0.5.0",

11609 "proc-macro2",

11610 "quote",

11611 "rustversion",

11612 "syn 2.0.119",

11613]

11614

11615[[package]]

11616name = "strum_macros"

805311617version = "0.27.2"

805411618source = "registry+https://github.com/rust-lang/crates.io-index"

805511619checksum = "7695ce3845ea4b33927c055a39dc438a45b059f7c1b3d91d38d10355fb8cbca7"

@@ -8061,6 +11625,18 @@

806111625]

806211626

806311627[[package]]

11628name = "strum_macros"

11629version = "0.28.0"

11630source = "registry+https://github.com/rust-lang/crates.io-index"

11631checksum = "ab85eea0270ee17587ed4156089e10b9e6880ee688791d45a905f5b1ca36f664"

11632dependencies = [

11633 "heck 0.5.0",

11634 "proc-macro2",

11635 "quote",

11636 "syn 2.0.119",

11637]

11638

11639[[package]]

806411640name = "subtle"

806511641version = "2.6.1"

806611642source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -8135,6 +11711,27 @@

813511711]

813611712

813711713[[package]]

11714name = "system-configuration"

11715version = "0.7.0"

11716source = "registry+https://github.com/rust-lang/crates.io-index"

11717checksum = "a13f3d0daba03132c0aa9767f98351b3488edc2c100cda2d2ec2b04f3d8d3c8b"

11718dependencies = [

11719 "bitflags 2.13.1",

11720 "core-foundation 0.9.4",

11721 "system-configuration-sys",

11722]

11723

11724[[package]]

11725name = "system-configuration-sys"

11726version = "0.6.0"

11727source = "registry+https://github.com/rust-lang/crates.io-index"

11728checksum = "8e1d1b10ced5ca923a1fcb8d03e96b8d3268065d724548c0211415ff6ac6bac4"

11729dependencies = [

11730 "core-foundation-sys",

11731 "libc",

11732]

11733

11734[[package]]

813811735name = "tagptr"

813911736version = "0.2.0"

814011737source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -8200,6 +11797,15 @@

820011797]

820111798

820211799[[package]]

11800name = "thread-tree"

11801version = "0.3.3"

11802source = "registry+https://github.com/rust-lang/crates.io-index"

11803checksum = "ffbd370cb847953a25954d9f63e14824a36113f8c72eecf6eccef5dc4b45d630"

11804dependencies = [

11805 "crossbeam-channel",

11806]

11807

11808[[package]]

820311809name = "thread_local"

820411810version = "1.1.10"

820511811source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -8209,6 +11815,20 @@

820911815]

821011816

821111817[[package]]

11818name = "tiff"

11819version = "0.11.3"

11820source = "registry+https://github.com/rust-lang/crates.io-index"

11821checksum = "b63feaf3343d35b6ca4d50483f94843803b0f51634937cc2ec519fc32232bc52"

11822dependencies = [

11823 "fax",

11824 "flate2",

11825 "half",

11826 "quick-error",

11827 "weezl",

11828 "zune-jpeg",

11829]

11830

11831[[package]]

821211832name = "time"

821311833version = "0.1.45"

821411834source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -8285,6 +11905,39 @@

828511905checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"

828611906

828711907[[package]]

11908name = "tokenizers"

11909version = "0.21.4"

11910source = "registry+https://github.com/rust-lang/crates.io-index"

11911checksum = "a620b996116a59e184c2fa2dfd8251ea34a36d0a514758c6f966386bd2e03476"

11912dependencies = [

11913 "ahash 0.8.12",

11914 "aho-corasick",

11915 "compact_str",

11916 "dary_heap",

11917 "derive_builder",

11918 "esaxx-rs",

11919 "getrandom 0.3.4",

11920 "itertools 0.14.0",

11921 "log 0.4.33",

11922 "macro_rules_attribute",

11923 "monostate",

11924 "onig",

11925 "paste",

11926 "rand 0.9.5",

11927 "rayon",

11928 "rayon-cond",

11929 "regex",

11930 "regex-syntax",

11931 "serde",

11932 "serde_json",

11933 "spm_precompiled",

11934 "thiserror 2.0.20",

11935 "unicode-normalization-alignments",

11936 "unicode-segmentation",

11937 "unicode_categories",

11938]

11939

11940[[package]]

828811941name = "tokio"

828911942version = "1.53.1"

829011943source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -8341,6 +11994,7 @@

834111994 "futures-core",

834211995 "pin-project-lite",

834311996 "tokio",

11997 "tokio-util",

834411998]

834511999

834612000[[package]]

@@ -8351,8 +12005,12 @@

835112005dependencies = [

835212006 "futures-util",

835312007 "log 0.4.33",

12008 "rustls",

12009 "rustls-pki-types",

835412010 "tokio",

12011 "tokio-rustls",

835512012 "tungstenite",

12013 "webpki-roots 0.26.11",

835612014]

835712015

835812016[[package]]

@@ -8405,7 +12063,7 @@

840512063source = "registry+https://github.com/rust-lang/crates.io-index"

840612064checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a"

840712065dependencies = [

8408 "indexmap",

12066 "indexmap 2.14.0",

840912067 "serde",

841012068 "serde_spanned",

841112069 "toml_datetime 0.6.11",

@@ -8419,7 +12077,7 @@

841912077source = "registry+https://github.com/rust-lang/crates.io-index"

842012078checksum = "6975367e4d2ef766d86af01ffad14b622fecc8d4357a998fbc4deb6e9bacaf9b"

842112079dependencies = [

8422 "indexmap",

12080 "indexmap 2.14.0",

842312081 "toml_datetime 1.1.1+spec-1.1.0",

842412082 "toml_parser",

842512083 "winnow 1.0.4",

@@ -8462,12 +12120,17 @@

846212120source = "registry+https://github.com/rust-lang/crates.io-index"

846312121checksum = "4cfcf7e2740e6fc6d4d688b4ef00650406bb94adf4731e43c096c3a19fe40840"

846412122dependencies = [

12123 "async-compression",

846512124 "bitflags 2.13.1",

846612125 "bytes",

12126 "futures-core",

846712127 "futures-util",

846812128 "http 1.5.0",

846912129 "http-body 1.1.0",

12130 "http-body-util",

847012131 "pin-project-lite",

12132 "tokio",

12133 "tokio-util",

847112134 "tower",

847212135 "tower-layer",

847312136 "tower-service",

@@ -8538,6 +12201,18 @@

853812201]

853912202

854012203[[package]]

12204name = "tracing-futures"

12205version = "0.2.5"

12206source = "registry+https://github.com/rust-lang/crates.io-index"

12207checksum = "97d095ae15e245a057c8e8451bab9b3ee1e1f68e9ba2b4fbc18d0ac5237835f2"

12208dependencies = [

12209 "futures",

12210 "futures-task",

12211 "pin-project",

12212 "tracing",

12213]

12214

12215[[package]]

854112216name = "tracing-log"

854212217version = "0.2.0"

854312218source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -8590,6 +12265,8 @@

859012265 "httparse",

859112266 "log 0.4.33",

859212267 "rand 0.9.5",

12268 "rustls",

12269 "rustls-pki-types",

859312270 "sha1 0.10.7",

859412271 "thiserror 2.0.20",

859512272]

@@ -8661,6 +12338,12 @@

866112338checksum = "5c1cb5db39152898a79168971543b1cb5020dff7fe43c8dc468b0885f5e29df5"

866212339

866312340[[package]]

12341name = "unicode-blocks"

12342version = "0.1.10"

12343source = "registry+https://github.com/rust-lang/crates.io-index"

12344checksum = "328edfd6d0bb91a22e592bed3a3b54c7b1f5c92a517f5a7aca24a2caef10c363"

12345

12346[[package]]

866412347name = "unicode-bom"

866512348version = "2.0.3"

866612349source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -8682,18 +12365,45 @@

868212365]

868312366

868412367[[package]]

12368name = "unicode-normalization-alignments"

12369version = "0.1.12"

12370source = "registry+https://github.com/rust-lang/crates.io-index"

12371checksum = "43f613e4fa046e69818dd287fdc4bc78175ff20331479dab6e1b0f98d57062de"

12372dependencies = [

12373 "smallvec",

12374]

12375

12376[[package]]

868512377name = "unicode-properties"

868612378version = "0.1.4"

868712379source = "registry+https://github.com/rust-lang/crates.io-index"

868812380checksum = "7df058c713841ad818f1dc5d3fd88063241cc61f49f5fbea4b951e8cf5a8d71d"

868912381

869012382[[package]]

12383name = "unicode-segmentation"

12384version = "1.13.3"

12385source = "registry+https://github.com/rust-lang/crates.io-index"

12386checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8"

12387

12388[[package]]

12389name = "unicode-width"

12390version = "0.2.2"

12391source = "registry+https://github.com/rust-lang/crates.io-index"

12392checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"

12393

12394[[package]]

869112395name = "unicode-xid"

869212396version = "0.2.6"

869312397source = "registry+https://github.com/rust-lang/crates.io-index"

869412398checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"

869512399

869612400[[package]]

12401name = "unicode_categories"

12402version = "0.1.1"

12403source = "registry+https://github.com/rust-lang/crates.io-index"

12404checksum = "39ec24b3121d976906ece63c9daad25b85969647682eee313cb5779fdd69e14e"

12405

12406[[package]]

869712407name = "universal-hash"

869812408version = "0.5.1"

869912409source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -8714,6 +12424,12 @@

871412424]

871512425

871612426[[package]]

12427name = "unsafe-libyaml"

12428version = "0.2.11"

12429source = "registry+https://github.com/rust-lang/crates.io-index"

12430checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861"

12431

12432[[package]]

871712433name = "untrusted"

871812434version = "0.7.1"

871912435source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -8726,6 +12442,25 @@

872612442checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"

872712443

872812444[[package]]

12445name = "ureq"

12446version = "2.12.1"

12447source = "registry+https://github.com/rust-lang/crates.io-index"

12448checksum = "02d1a66277ed75f640d608235660df48c8e3c19f3b4edb6a263315626cc3c01d"

12449dependencies = [

12450 "base64 0.22.1",

12451 "flate2",

12452 "log 0.4.33",

12453 "once_cell",

12454 "rustls",

12455 "rustls-pki-types",

12456 "serde",

12457 "serde_json",

12458 "socks",

12459 "url 2.5.8",

12460 "webpki-roots 0.26.11",

12461]

12462

12463[[package]]

872912464name = "url"

873012465version = "1.7.2"

873112466source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -8781,6 +12516,12 @@

878112516checksum = "c8232dd3cdaed5356e0f716d285e4b40b932ac434100fe9b7e0e8e935b9e6246"

878212517

878312518[[package]]

12519name = "utf8-ranges"

12520version = "1.0.5"

12521source = "registry+https://github.com/rust-lang/crates.io-index"

12522checksum = "7fcfc827f90e53a02eaef5e535ee14266c1d569214c6aa70133a624d8a3164ba"

12523

12524[[package]]

878412525name = "utf8_iter"

878512526version = "1.0.4"

878612527source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -8792,7 +12533,7 @@

879212533source = "registry+https://github.com/rust-lang/crates.io-index"

879312534checksum = "8bde15df68e80b16c7d16b9616e80770ad158988daa56a27dccd1e55558b0160"

879412535dependencies = [

8795 "indexmap",

12536 "indexmap 2.14.0",

879612537 "serde",

879712538 "serde_json",

879812539 "utoipa-gen",

@@ -8842,6 +12583,17 @@

884212583]

884312584

884412585[[package]]

12586name = "v_frame"

12587version = "0.3.9"

12588source = "registry+https://github.com/rust-lang/crates.io-index"

12589checksum = "666b7727c8875d6ab5db9533418d7c764233ac9c0cff1d469aec8fa127597be2"

12590dependencies = [

12591 "aligned-vec",

12592 "num-traits",

12593 "wasm-bindgen",

12594]

12595

12596[[package]]

884512597name = "valuable"

884612598version = "0.1.1"

884712599source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -8968,6 +12720,32 @@

896812720]

896912721

897012722[[package]]

12723name = "wasm-streams"

12724version = "0.4.2"

12725source = "registry+https://github.com/rust-lang/crates.io-index"

12726checksum = "15053d8d85c7eccdbefef60f06769760a563c7f0a9d6902a13d35c7800b0ad65"

12727dependencies = [

12728 "futures-util",

12729 "js-sys",

12730 "wasm-bindgen",

12731 "wasm-bindgen-futures",

12732 "web-sys",

12733]

12734

12735[[package]]

12736name = "wasm-streams"

12737version = "0.5.0"

12738source = "registry+https://github.com/rust-lang/crates.io-index"

12739checksum = "9d1ec4f6517c9e11ae630e200b2b65d193279042e28edd4a2cda233e46670bbb"

12740dependencies = [

12741 "futures-util",

12742 "js-sys",

12743 "wasm-bindgen",

12744 "wasm-bindgen-futures",

12745 "web-sys",

12746]

12747

12748[[package]]

897112749name = "web"

897212750version = "0.1.0"

897312751source = "git+https://gitea.gitdata.me/GitDataAi/web.git?rev=67436b2ad9#67436b2ad97b6d0ccc548cb3b1d5691711a01214"

@@ -9019,6 +12797,24 @@

901912797]

902012798

902112799[[package]]

12800name = "webpki-root-certs"

12801version = "1.0.9"

12802source = "registry+https://github.com/rust-lang/crates.io-index"

12803checksum = "b96554aa2acc8ccdb7e1c9a58a7a68dd5d13bccc69cd124cb09406db612a1c9b"

12804dependencies = [

12805 "rustls-pki-types",

12806]

12807

12808[[package]]

12809name = "webpki-roots"

12810version = "0.26.11"

12811source = "registry+https://github.com/rust-lang/crates.io-index"

12812checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9"

12813dependencies = [

12814 "webpki-roots 1.0.9",

12815]

12816

12817[[package]]

902212818name = "webpki-roots"

902312819version = "1.0.9"

902412820source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -9028,6 +12824,12 @@

902812824]

902912825

903012826[[package]]

12827name = "weezl"

12828version = "0.1.12"

12829source = "registry+https://github.com/rust-lang/crates.io-index"

12830checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88"

12831

12832[[package]]

903112833name = "whoami"

903212834version = "2.1.3"

903312835source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -9148,6 +12950,17 @@

914812950]

914912951

915012952[[package]]

12953name = "windows-registry"

12954version = "0.6.1"

12955source = "registry+https://github.com/rust-lang/crates.io-index"

12956checksum = "02752bf7fbdcce7f2a27a742f798510f3e5ad88dbe84871e5168e2120c3d5720"

12957dependencies = [

12958 "windows-link",

12959 "windows-result",

12960 "windows-strings",

12961]

12962

12963[[package]]

915112964name = "windows-result"

915212965version = "0.4.1"

915312966source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -9194,6 +13007,15 @@

919413007

919513008[[package]]

919613009name = "windows-sys"

13010version = "0.60.2"

13011source = "registry+https://github.com/rust-lang/crates.io-index"

13012checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"

13013dependencies = [

13014 "windows-targets 0.53.5",

13015]

13016

13017[[package]]

13018name = "windows-sys"

919713019version = "0.61.2"

919813020source = "registry+https://github.com/rust-lang/crates.io-index"

919913021checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"

@@ -9225,7 +13047,7 @@

922513047 "windows_aarch64_gnullvm 0.52.6",

922613048 "windows_aarch64_msvc 0.52.6",

922713049 "windows_i686_gnu 0.52.6",

9228 "windows_i686_gnullvm",

13050 "windows_i686_gnullvm 0.52.6",

922913051 "windows_i686_msvc 0.52.6",

923013052 "windows_x86_64_gnu 0.52.6",

923113053 "windows_x86_64_gnullvm 0.52.6",

@@ -9233,6 +13055,23 @@

923313055]

923413056

923513057[[package]]

13058name = "windows-targets"

13059version = "0.53.5"

13060source = "registry+https://github.com/rust-lang/crates.io-index"

13061checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"

13062dependencies = [

13063 "windows-link",

13064 "windows_aarch64_gnullvm 0.53.1",

13065 "windows_aarch64_msvc 0.53.1",

13066 "windows_i686_gnu 0.53.1",

13067 "windows_i686_gnullvm 0.53.1",

13068 "windows_i686_msvc 0.53.1",

13069 "windows_x86_64_gnu 0.53.1",

13070 "windows_x86_64_gnullvm 0.53.1",

13071 "windows_x86_64_msvc 0.53.1",

13072]

13073

13074[[package]]

923613075name = "windows-threading"

923713076version = "0.2.1"

923813077source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -9254,6 +13093,12 @@

925413093checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"

925513094

925613095[[package]]

13096name = "windows_aarch64_gnullvm"

13097version = "0.53.1"

13098source = "registry+https://github.com/rust-lang/crates.io-index"

13099checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"

13100

13101[[package]]

925713102name = "windows_aarch64_msvc"

925813103version = "0.48.5"

925913104source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -9266,6 +13111,12 @@

926613111checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"

926713112

926813113[[package]]

13114name = "windows_aarch64_msvc"

13115version = "0.53.1"

13116source = "registry+https://github.com/rust-lang/crates.io-index"

13117checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"

13118

13119[[package]]

926913120name = "windows_i686_gnu"

927013121version = "0.48.5"

927113122source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -9278,12 +13129,24 @@

927813129checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"

927913130

928013131[[package]]

13132name = "windows_i686_gnu"

13133version = "0.53.1"

13134source = "registry+https://github.com/rust-lang/crates.io-index"

13135checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"

13136

13137[[package]]

928113138name = "windows_i686_gnullvm"

928213139version = "0.52.6"

928313140source = "registry+https://github.com/rust-lang/crates.io-index"

928413141checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"

928513142

928613143[[package]]

13144name = "windows_i686_gnullvm"

13145version = "0.53.1"

13146source = "registry+https://github.com/rust-lang/crates.io-index"

13147checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"

13148

13149[[package]]

928713150name = "windows_i686_msvc"

928813151version = "0.48.5"

928913152source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -9296,6 +13159,12 @@

929613159checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"

929713160

929813161[[package]]

13162name = "windows_i686_msvc"

13163version = "0.53.1"

13164source = "registry+https://github.com/rust-lang/crates.io-index"

13165checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"

13166

13167[[package]]

929913168name = "windows_x86_64_gnu"

930013169version = "0.48.5"

930113170source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -9308,6 +13177,12 @@

930813177checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"

930913178

931013179[[package]]

13180name = "windows_x86_64_gnu"

13181version = "0.53.1"

13182source = "registry+https://github.com/rust-lang/crates.io-index"

13183checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"

13184

13185[[package]]

931113186name = "windows_x86_64_gnullvm"

931213187version = "0.48.5"

931313188source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -9320,6 +13195,12 @@

932013195checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"

932113196

932213197[[package]]

13198name = "windows_x86_64_gnullvm"

13199version = "0.53.1"

13200source = "registry+https://github.com/rust-lang/crates.io-index"

13201checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"

13202

13203[[package]]

932313204name = "windows_x86_64_msvc"

932413205version = "0.48.5"

932513206source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -9332,6 +13213,12 @@

933213213checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"

933313214

933413215[[package]]

13216name = "windows_x86_64_msvc"

13217version = "0.53.1"

13218source = "registry+https://github.com/rust-lang/crates.io-index"

13219checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"

13220

13221[[package]]

933513222name = "winnow"

933613223version = "0.7.15"

933713224source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -9403,6 +13290,12 @@

940313290checksum = "aee1b19627c7c60102ab80d3a9cbe18de90bfe03bfa6c3715447681f0e8c8af6"

940413291

940513292[[package]]

13293name = "y4m"

13294version = "0.8.0"

13295source = "registry+https://github.com/rust-lang/crates.io-index"

13296checksum = "7a5a4b21e1a62b67a2970e6831bc091d7b87e119e7f9791aef9702e3bef04448"

13297

13298[[package]]

940613299name = "yansi"

940713300version = "1.0.1"

940813301source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -9522,7 +13415,7 @@

952213415 "arbitrary",

952313416 "crc32fast",

952413417 "flate2",

9525 "indexmap",

13418 "indexmap 2.14.0",

952613419 "memchr",

952713420 "zopfli",

952813421]

@@ -9578,3 +13471,27 @@

957813471 "cc",

957913472 "pkg-config",

958013473]

13474

13475[[package]]

13476name = "zune-core"

13477version = "0.5.3"

13478source = "registry+https://github.com/rust-lang/crates.io-index"

13479checksum = "d56377fd46368984a170bc5aac5567e52ca5da874caa60bea39fcbca78fb658b"

13480

13481[[package]]

13482name = "zune-inflate"

13483version = "0.2.54"

13484source = "registry+https://github.com/rust-lang/crates.io-index"

13485checksum = "73ab332fe2f6680068f3582b16a24f90ad7096d5d39b974d1c0aff0125116f02"

13486dependencies = [

13487 "simd-adler32",

13488]

13489

13490[[package]]

13491name = "zune-jpeg"

13492version = "0.5.15"

13493source = "registry+https://github.com/rust-lang/crates.io-index"

13494checksum = "27bc9d5b815bc103f142aa054f561d9187d191692ec7c2d1e2b4737f8dbd7296"

13495dependencies = [

13496 "zune-core",

13497]

Modified Cargo.toml +5 −23 View Cargo.toml

@@ -1,27 +1,7 @@

11[workspace]

22members = [

3 "lib/auth",

4 "lib/cache",

5 "lib/chat",

6 "lib/config",

7 "lib/email",

8 "lib/export",

9 "lib/models",

10 "lib/pow-solver",

11 "lib/session",

12 "lib/storage",

13 "lib/user",

14 "lib/space",

15 "lib/issues",

16 "lib/git",

17 "lib/webapi",

18 "lib/pulls",

19 "app/apihost",

20 "app/githost",

21 "app/mails",

22 "app/migrate",

23 "app/openapi",

24 "app/synchost"

3 "lib/*",

4 "app/*"

255]

266

277resolver = "3"

@@ -49,6 +29,7 @@

4929git = { path = "lib/git" }

5030webapi = { path = "lib/webapi" }

5131pulls = { path = "lib/pulls" }

32agent = { path = "lib/agent" }

5233

5334

5435

@@ -96,7 +77,8 @@

9677thiserror = "2.0.20"

9778gix = "0.86.0"

9879gitbaby = { git="https://gitea.gitdata.me/GitDataAi/GitBaby.git", rev = "69bd99a" }

99cubesanbox = { git = "https://gitea.gitdata.me/GitDataAi/sanbox-client.git", rev = "91ba6f56ac" }

80cubesandbox = { git = "https://gitea.gitdata.me/GitDataAi/sanbox-client.git", rev = "91ba6f56ac" }

81rig = "0.42"

10082wasm-bindgen = "0.2"

10183chrono = "0.4.45"

10284maud = { version = "0.27", features = ["axum"] }