Crate tasktree 

tasktree

Distributed task-tree values: W3C trace-compatible task identities under an application-supplied URN scheme, validated lifecycle transitions, parent-child lineage, progress, and timestamps.

This crate is deliberately runtime-independent — no async, no I/O, no executor. It is the value layer a distributed task engine is built on; the engine (registries, admission, execution, event streams) is yours.

• Identity — a TaskTreeId is W3C trace-sized (16 bytes) and a TaskNodeId span-sized (8 bytes), so every task maps directly onto Trace Context: a tree id parses from its URN, a bare trace id, or a full traceparent header. Every tree has one reserved root node, and TaskId::child mints siblings inside the tree.
• Your namespace, not ours — identities are minted under a UrnScheme the application defines; this crate ships no namespace of its own, so no third party can mint another system’s URNs and two systems’ identities can never be confused, even at the type level. Prefixes are validated at compile time.
• Lifecycle — TaskStatus with a validated transition machine (admitted → queued → running → sealing → done/failed/cancelled); terminal states admit no exits, and the irreversible sealing region refuses cancellation. Illegal edges are unrepresentable as TaskTransition values.
• Lineage — TaskLineage proves a parent-child edge is within one tree and never self-referential, enforced again on deserialization.
• Progress — typed units, bounded aggregation, display fractions, and lifecycle timestamps.

use tasktree::{TaskId, TaskLineage, TaskStatus, UrnScheme};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
struct MyUrn;

impl UrnScheme for MyUrn {
    const TASK_PREFIX: &'static str = "urn:my-app:task:";
    const TREE_PREFIX: &'static str = "urn:my-app:task-tree:";
}

let root: TaskId<MyUrn> = TaskId::generate();
let child = root.child();
assert!(root.as_str().starts_with("urn:my-app:task:"));

let edge = TaskLineage::try_new(child, root).expect("same tree, not self");
assert!(TaskStatus::Running.validate_transition(TaskStatus::Sealing).is_ok());

Serde uses the URN string form throughout, and every deserialization re-validates: a foreign prefix, a zero identity, or an illegal transition never becomes a value.

License

Licensed under either of:

• Apache License, Version 2.0 (LICENSE-APACHE);
• MIT License (LICENSE-MIT).

Links

Structs

TaskId

Canonical, globally usable identity of one task, minted under the application’s UrnScheme.

TaskIdentityError

A malformed task identity.

TaskLineage

A validated child and its exact parent in one distributed task tree.

TaskNodeId

W3C span-sized identity for one task node.

TaskProgress

Progress counters for a running task.

TaskProgressUpdate

A single progress observation for a task.

TaskTimestamps

Unix-epoch timestamps tracking the lifecycle of a task.

TaskTransition

One validated lifecycle transition.

TaskTransitionError

An illegal task lifecycle transition.

TaskTreeId

W3C trace-sized identity for one distributed task tree, minted under the application’s UrnScheme.

Enums

ProgressUnit

The unit of measurement for progress counters.

TaskEventLevel

Verbosity tier of a task activity event.

TaskLineageError

A structurally invalid task lineage.

TaskStatus

Lifecycle status of a task.

Traits

UrnScheme

The URN namespace an application mints its task identities under.