Expand description
Facade/prelude: the derivation engine, indicator state machines, and the storage tier. Depend on this crate only — sub-crates are wiring detail.
Macros§
- always_
present - The identity
Present: an item that is its value, absent only by not being emitted. One line per type because the blanket impl is spent onOptionand Rust has no specialization. - graph
- Builds a frame from its outputs: the node set, its topological order, the
Emitterwrapping, the latches and theBuffers (each sized to the join of every read taken of it) are all derived from the annotatedtype Depsof the cells the outputs reach. - node_
alias - A
typealias to a cell, declared sographcan follow it. - slice_
nudge - A slice-out cell’s finite-difference witness: copy the batch into
Vec<$E>scratch, bump the last element when asked, view it back at the borrow’s own lifetime. Also the cell’sSeriesdeclaration — “this out is a run of$E” is exactly what both traits need to know. - value_
nudge - A value-out cell’s finite-difference witness: the scratch is just the value itself.
Structs§
- Aggregate
- A fold over many wire messages: one span per actor,
firstresetting on every resync. - Armed
- An
Episodicnode’s own contact, sealed in: an ordinary node stepped beforeN, soNand any leg meant to go dark with it name it in aGatingdep. It folds its trigger atHorizon::Unboundedby construction — a latched bit is exactly the state nothing reconstitutes — which is also why it can never itself be gated. - Arrival
- Weaver ordering key. Monotonic by construction, not by measurement: when events arrive faster than the clock resolves, it is the previous key plus one. So it is deliberately not subtractable — the gap between two arrivals is not an elapsed duration.
- Asset
- Awake
- The past that is never read, because the node it would rewind never sleeps. Erased through
REWINDS, so a graph driven with this is the sweep it was before anything was anchored. - Bar
- Bars
- Stateless: both accumulators close a period on the same trade, so the join is this tick’s two batches zipped.
- Batch
Trades - Batched trade stream event. All trades share
prec. - Book
- The book fold. Domain-only — it knows nothing of
Cell/Node; the graph node wraps this throughBook::step, andShadowBookwraps the same instance, so the persisted stream and the replayed one cannot drift. - Book
Anchors - Anchors are
Book’s input, not the graph’s — nothing else should name this. - Book
Chunk - The net effect of one period’s deltas.
- Book
Delta - One level of our own recollection — see
ShadowBook: the persisted delta lane is gapless and self-consistent, sokind(not the venue’sgappedflag) is what a consumer reads. This is the stored row; unlike every other lane holder it carries its own precision, because aSerieshands out bare items and a raw price no consumer can scale is not a reading. The persistence tier fills it from the file’s schema. - Book
Deltas - Book
Shape - (price, qty) levels for both sides of an orderbook, keyed by raw price.
The wire/persist shape. Both BTreeMaps are ascending;
Bookholds the same levels best-first. - Buffering
- Dep position only, never a frame field: “this series, retained at least
Rback”. Resolves against the frame’s [Buffer<C, K>] through theHasimpl below, whose const-assert proves the declared reachservesthe request. - Carried
- What a
Foldsnode carries between its elements. Zero at the start of a run and at every reset — a recurrence that needs a different zero says so with a counter slot and aselect, which is also how it says it is not warm yet. - Catalog
- Close
- The kernel of a
Closesnode. - Dep
- A dep as its position: the view a
readselects off, and what mints every reading. A body names which element it wants and gets it back tagged with the dep it came from, so provenance records what happened rather than what was claimed. - Elems
- A count of elements —
Horizon::Elemsas a type. - Ema
- Nautilus’s
ExponentialMovingAverage:α = 2/(len+1), seeded on the first sample, absent untillensamples have reached it. - EmaWindow
Ema’s weights,α = 2/(len+1), over the lastKelements — see the windowed smoothers above.- Env
- What a per-element kernel’s
readfills: the body’s env, and — where one is watching — which element of which dep each slot was copied from. - Ex
- Operator-ergonomics handle:
x*y + constant(2.0)builds the nested type. Delegates everyExprmethod to its inner primitive. - Exact
- Same-actor difference: one clock read twice, so no skew term.
- Feather
- Typed lane writer: a key/schema mismatch is unrepresentable, push is monomorphic.
- Field
- A named slot of an item — one per
#[slot]field, written by#[derive(Item)]. Carrying the item in the type is what makes a field of some other item a compile error rather than a column silently describing the wrong number. - Fire
- One node firing, flattened: values and the finite-difference local Jacobian wrt its deps, à la Jane Street’s “Computations that differentiate and document themselves”.
- Fold
- The kernel of a
Foldsnode. - Folding
- Dep position only, never a frame field: “this dep,
Hof which I hold myself”. The out is the bare cell’s — nothing wraps the data and nothing is retained for it, so this is a pure declaration, the node’s own recurrence or window stated where it is actually about. - Gains
- The up moves of
X, and zero where it fell. - Gating
- Dep position only, never a frame field: the input that dominates. While it reads false its
consumer does not advance — no other dep is pulled, and the out is
Latent::latent. - Guide
- Constant horizontal guide line in the node’s pane (e.g. RSI 30/70).
- Hist
- A
Bufferingdep’s out:all = past ++ fresh, wherefreshis byte-identical to the unbuffered series out andpastis what stood behind this tick’s batch.horizonis the consumer’s declared one, so a window wider than it stated trips regardless of how far the frame’s buffer happens to reach. - Ink
- l/c/a only — hue is the renderer’s; a node can never claim one.
- Inner
Trade - One trade in raw (scaled-int) form;
price/qtyare meaningless without the batch’sprec. - Lane
Reader - Streams one lane’s rows in
[start, end], one parquet file at a time. No whole-lane materialization; a mid-stream read failure of a catalog-owned file is unrecoverable and panics. - Lanes
- Latency
Config - A log-normal latency model fitted to three percentiles, seeded deterministically. Build a
per-stream
LatencySamplerwithLatencyConfig::sampler: the seed is hashed with the stream’s key, so identical config ⇒ identical stream, distinct keys ⇒ distinct streams. - Live
- Live feed.
Feed::nextdrains what’s currently available (blocking for the first event), stamps each message with a monotonic arrival time, weaves one step, and drops consumed rows — memory stays bounded to the un-emitted window regardless of session length. Recording tees incrementally.Noneonce every sink is dropped and the buffer is drained. - Live
Clock - Local
- Our own process.
- Losses
- The down moves of
Xas a positive magnitude, and zero where it rose. - Mc
- Market cap. The source reports no event time, so the only reading is ours — this lane’s
axis is
Local, and venue-named columns would be a lie about whose clock produced it. - McRoot
- Moved
- A level output as the tick hands it over: the out that stands, and whether this tick moved it.
- Ohlc
- Ohlcs
- The series over a period, in three: the two accumulators over trades, and the bar that is their
join. The period is a parameter rather than a name the framework pre-blessed — a node’s identity
is still its type, and a
Barsover one minute is as distinct from one over five as two newtypes were. OnlyTagis new: the period has to reachCell::NAMEfor the DAG card to keep sayingBar:1m. - Oi
- Open interest, base units.
- OiRoot
- Over
- A window of wall clock —
Horizon::Overas a type. - Pair
- Part
- One named field of one element —
Pick’s partial, landing in that field’s own column. - Past
- Everything already delivered on the lanes something may be replayed out of, and nothing else. The slices are truncated where the weave stands, so a row it has not emitted is not representable here — which is the whole of what keeps a rewind from reading its own future.
- Pending
- The period a
Closesnode is part way through: the accumulator’s slots and the time they close at. Held by the node because the engine owns no storage for one, and read by nothing but the kernel — the body sees the slots as an env and never this struct. - Pick
- One element of one dep, at the lag that dep handed it out at — the reading a body puts. Derefs to
the element, so a selection may read what is not a slot: an event time above all, which is the
kernel’s to carry and never a variable (
r[kernels.selection.index-is-not-a-variable]). - Plot
- Optional drawing hints a node declares about one group of its
Flatslots — the renderer owns everything else (hue above all). Defaults always suffice. - Precision
- Decimal exponent:
raw = value × 10^precision. Signed, so a million-dollar index tick and a satoshi tick both fit the same 32-bit raw column. - Precision
Price Qty - Per-batch precision shared across all levels / trades in a book / trade batch.
- Predicate
- The kernel of a
Decidesnode. - Read
Clock - How coarsely a backtest batches, so that it runs faster than the market it replays. That is the whole of it. Arrival time is cut into cells of this length and everything landing in one cell is handed to the graph as a single step, so a replay does a day’s work in as many steps as the cell size buys rather than one per message.
- Reading
- A number a body may not have: absent exactly where its payload is NaN, which is the
representation and not a sentinel a reader has to know about
(
r[impl outs.absence.typed]). Eight bytes whereOption<f64>is sixteen — every bit pattern of anf64is a valid one, so the discriminant can never be packed into the payload and a retained series of them was paying twice for what the payload already said. - Relay
Cols Relay’s columnar twin: per element where the element attests, on the holder where the run does. Both shapes stay —Relayfor a single event, this for a run.- Replay
- Backtest feed: fills the weaver from the catalog’s lanes, then emits their arrival-ordered
merge. Historic rows (no recorded reception) get a simulated arrival via
latency. - Rotation
Policy - Rows
- The default
Batch: every row, trimmed on timestamps where its items areTimedand by count where they are not, handed out as aHist. - Rsi
100 - 100/(1 + U/D)over an average of a series’Gainsand one of itsLosses. Which average is the wiring’s to say: Wilder’s is the classic RSI.- RsiDelta
- Close-to-close change on
B— the series RSI’s up and down moves are taken of. - Sampling
- Dep position only: “the last value
Cproduced, whenever that was”. Its slot in the frame is keyed on this type itself — the [carry] behind it is storage, not a cell, the same way an [Emitter] is. - Scan
- The kernel of a
Scansnode: one out element per driving element, each slotbody().eval, and the Jacobianbody().gradat the last element — exact, and one pass rather than a clone and a re-emit per dep slot. - Shadow
Book - We persist our own recollection, not the venue’s story. A gap or a resync is a fact about our connection; stored raw, every replay would re-derive the reconciliation from whatever venue snapshots happened to land. Reconciled once here, replay is exact and free.
- Sink
- Cloneable push handle: just enqueues. Arrival time is stamped at ingest (single-threaded), so the handle is clock-free and cheap to clone across pump tasks.
- Span
- The window one actor’s readings of a folded object span.
firstis the start of the current accumulation epoch — it resets on resync, it is not “when the object was allocated”. - Step
- One emission, and the past it stands on. Two values rather than one because
Feed::nextties itsLanesto&mut self, so the feed cannot be read alongside the batch it just handed out. - Symbol
- Tag
- A
Cell::NAMEa parameter can reach.NAMEis aconst &'static str, and nothing that formats at runtime can produce one — so the parts are spelled into a fixed buffer, in an associated const, whose value outlives theNAMEborrowing it. That an associated const may read its impl’s generics, where a freeconstitem may not, is the whole reason this works. - Tail
- A prefix of a run, carrying how far its own end stands behind the run’s newest, and the dep it was cut from. A cross-rate reader cuts a series at its own deadline and then picks inside the cut; without this the pick would report a lag against the cut instead of against the column it lands in.
- Timeframe
- The period a
Bars<TF>is over: naming one is now part of wiring a graph, and a facade-only consumer has no other route to the type. Implemented over the number of milliseconds - Trade
- One stored trade, raw as the venue sent it:
price/qtyare meaningless without the lane’s precision. It is the disk row, never a graph view — nodes readTradeCols. - Trade
Buf - Owned twin of
TradeCols: lane buffer,Nudgescratch and ingest accumulator in one. - Trade
Cols - Trades
- Ts
- Nanoseconds since the Unix epoch, tagged with the actor whose clock produced it.
- Unbounded
- Reaches to the start of the run —
Horizon::Unboundedas a type. - Usd
- A struct representing USD (in future, inflation-adjusted) value. That’s it. Just a newtype. But extremely powerful.
- Vars
- The dep-slot dispenser handed to a
trading_data_dag::Symbolicbody:v.get::<I>()is theVarreading depI(bounds enforced at eval time byenvlength). - Venue
- The exchange a fact originates from.
- Volume
- Volumes
- Wilder
- Wilder’s running mean: an SMA over the first
lensamples, then(prev·(len-1) + x)/len. Absent until warm. - Wilder
Window Wilder’s weights,α = 1/len, over the lastKelements — see the windowed smoothers above.- Win
- A trailing window, every element of which knows its own lag — so a body folding one names no offsets and computes none.
- Zipf
- Mean of
Xunder weight(k+1)^-son the samplekback, normalised by the weight the history seen so far carries — which tends toζ(s).
Enums§
- Book
Update - Distinguishes full snapshots from incremental deltas. For deltas: qty=0 means remove that price level.
- Catalog
Error - Direction
- A position’s sign.
Flatis a decision — that there is nothing here — whereNoneupstream is the absence of one. - Exchange
Name - Fidelity
- How much of what a node’s body read the kernel’s fullest reading covers
(
r[kernels.fidelity.stated]) —Kernel::jacwhere there is nothing wider, andKernel::exactwhere there is. Three answers rather than two, because the middle one is the case nothing else can show: a derivative may be algebraic and still be narrower than the reading it was taken from, and a partial derivative of a body that reads a window looks exactly like an exact one of a body that reads a point. - Frame
Kind - Whether a level is market activity or our own reconciliation — a
UInt8column exactly parallel to the side byte. Per row, not per run: what a run of levels is, is what its rows say it is, and the one consumer that discriminates (a flow derivation, which a correction would feed fabricated signal) filters on it. - Horizon
- How far back a dep position reaches: nothing at all (a bare dep), the engine’s retention
(
Buffering), or the consumer’s own state (Folding). One vocabulary for all three, so the reach a node reads and the reach it holds are stated the same way — and aconstof it drops straight into const-generic position. - Instrument
- Lane
Kind - The source lanes a graph may require.
Debug/Hashback the deterministic per-lane latency seed; the router reads only the lanes in the graph’s dep tree. Deltas and anchors are separate kinds: naming one must not load and accumulate the other, since an un-drained lane inLivegrows without bound. - Side
- Timeframe
Designator - The period a
Bars<TF>is over: naming one is now part of wiring a graph, and a facade-only consumer has no other route to the type. - Want
- How much of a fire the observer reads. Everything above
Want::Valsis second order — anOpaquenode’s Jacobian is oneclone_fromplus one re-advanceper scalar dep slot, and aPureone’s is agradpass over the pre-advance body — so it is priced per tick, never per build.
Traits§
- Batch
- How a [
Buffer] holds aSeries’ retained reach. The defaultRowskeeps every row; a series whose rows collapse — a book’s levels keep only the last qty per price — implements its own and pays its own state rather than the row count. - Blind
- The stated hatch: a node that computes in Rust and therefore has no algebra reading.
WHYis not documentation, it is the cost of using it —graph!counts these, and a graph that pins the count only lets it fall. - Bump
- Typed-space perturbation of one flattened element, for the finite-difference witness. Returns
the perturbation actually applied, in the element’s own units — a quantized column can only
move in whole ticks, and pretending otherwise divides the difference by a step never taken.
0.0⇒ this slot cannot be perturbed (discrete, structural), so its Jacobian column stays NaN rather than a fabricated zero. - Cell
- A value slot in the frame.
Out<'t>: Copy— references areCopy, so a batch out enters the frame as&'t [T]and heavy root/node state is lent as&'t State. - Clock
- Closes
- A run-shaped node whose elements are periods, closed by the first driving element past a boundary. The kernel owns the walk and the close time; the body owns the numbers, as three expressions — what a period’s first element opens with, what a further element folds into it, and what a period no element reached is.
- Decides
- A scalar
boolnode: a driving dep that clocks it — the leading one, whose having fired at all is half the verdict — and whatever it reads at their last elements, compared by anExpr. - Episode
- Episode lifecycle on an out value; the initial state is the node’s
Default. - Episodic
- A node that runs a self-terminating episode, latched from inside the graph.
Triggeris the one dep that stays live while the episode is dark — the arm — and the node’s ownEpisode::terminalout drops the contact. Where a hand-writtenLatchleaves the loop open (nothing checks that the gate you armed is the gate your episode cuts), this closes it in the type:Armed<Self>is the only gate it can be. - Expr
- One expression node: evaluate, accumulate exact partials, or project to
Ast. - Feed
- A source of woven lanes.
None= exhausted (end-of-range forReplay; all senders dropped and drained forLive). - Flat
- A cell output as a fixed-shape element array: the unit of observation and differentiation.
DIMSis the shape ([]scalar,[n]vector,[r, c]row-major, any rank). A batch out (&[T]) flattens to its last element — the observer sees end-of-batch. - Folds
- A run-shaped node computing one out element per element of its driving dep, carrying state between them. Two expressions over one env: what the state becomes, and what the element then is.
- Gate
- A binary control signal. A node naming it through a
Gatingdep is not advanced while it is false: deps not pulled, no work done, out =Latent::latent. Gates are scalar-out. - Glance
- The headline a human reads off a node at a glance — one compact line for the graph viz, the
display-dual of
Flat’s numeric flattening. A batch renders its last element (empty ⇒[]), matching the observer’s end-of-batch view. - Kernel
- How a node computes, and therefore what can be read off it. Sealed: the kernel set is the framework’s, so a node’s only choice is which one it names and there is no way to supply a body the engine cannot also read.
- Lagged
- A dep out one element of which a reading may select, with how far that element stands behind the
run’s newest — the element a dep’s
Jaccolumn stands for. Nothing reaches this directly: the element travels as aPick, which isDep’s to mint, so no site countslen - 1 - i. - Latch
- A
Gatearmed from outside and cut from within — the SCR/thyristor: an external event (itsDeps) sets it, conduction latches in its own state, and it turns off by natural commutation when the episode it gates reaches aEpisode::terminalout. No second external signal ever closes it.Cutis read post-sweep; commutation + the gated-node resets are deferred to the next tick’s start (the frame still borrows batch fields at end-of-tick). - Length
- A smoothing length — a number an app reading it from a config file has no const to give.
- Nudge
- A cell’s finite-difference witness: materialize a pulled out into owned scratch (
Nudge::stage, bumping one element whenbumpisSome), then hand it back at a fresh borrow lifetime (Nudge::view). The materialize step owns the data — a slice cell copies its batch intoScratch = Vec<T>, a value cell stores the value inScratch— which unties the re-advance lifetime from the pulled't, so re-advanceing a short-lived clone typechecks. No blanket impl — the value/slice cases overlap — so every observed cell writes its own short impl. - Observer
- Sees every
step_obsas it happens: one interpretation choke point, many interpretations. Step order IS topo order, so the observed sequence doubles as the graph’s static topology; dep names never seen as stepped nodes are roots — apps seed root activations viaobserve_root. - Present
- A
Seriesitem read as “did this element carry anything” — what [carry] must ask before it keeps one as a level. The dominant item in this codebase isOption<f64>, a rate-preserving decline; retaining one of those as the standing value would hold an absence forever. - Probabilistic
Distribution - A
Flatout whose slots are probabilities over a named outcome space. Evidence reaches one as points rather than shares: a read argues only for what it names, and what nothing argued for is ignorance rather than a uniform guess — so the space has to own a slot to be ignorant in, which is what theDefaultbound buys. - Put
- One reading an
Envtakes: a copy of one element’s slots, and the three coordinates it came from. Implemented by the tokens aDepmints and by nothing else — which is what leaves an author no way to state a provenance, and so no way to state a wrong one. - Reach
- A reach in dep position, where
Horizonis the same thing as a value — what the engine joins and compares. The two vocabularies coexist deliberately:Buffer<C, K>takes aHorizonbecausegraph!computesKas the join of every read of the series, and no type could name a join over reads that have not been seen yet. - Rewound
- A past for one node: what it needs to fold itself forward over the ticks it was not stepped on. Indexed by the node and implemented by the driver’s feed — the dag names no storage, so what a past is is not this crate’s to say.
- Roots
- A graph’s required root events — its dep tree, computed in isolation: the
TypeIdof each declared root event whose root is consumed by some node.graph!implements it; the facade maps theTypeIds to source lanes. - Row
- A lane’s row type. Sealed: the set of lanes is this crate’s contract with the disk.
- Runs
- The run side’s stated hatch —
Blind’s sibling: a node that fills its run in Rust and therefore has no algebra reading. The engine owns the run, so the struct holds only what it remembers between ticks, andemitcannot read what it wrote last tick.&mut self, not&'t mut self: the node is not lent for the tick, only the engine’s buffer is. - Scans
- A run-shaped node computing one out element per element of its driving dep — the leading one
in
Deps, whose rate it therefore preserves — carrying nothing between elements. Every number is anExpr, one per slot of the item; which elements of which deps the expression reads is Rust, licensed byr[kernels.selection.index-is-not-a-variable]: an index is constant wrt every differentiation variable, so it has no slope to state and the body differentiates only values. - Series
- A cell whose out is a run of
Items — the bufferable shape. The associatedItemis what keeps theBufferingHasimpl below free of an unconstrained element parameter (E0207).slice_nudge!declares it. - Slots
- One expression per slot of a multi-slot out — what a per-element kernel evaluates to fill an
item. Heterogeneous, so a tuple rather than
Sum’s homogeneous array: the slots of an item are different functions of one env, and a single-slot out is the one-tuple spelled without brackets. - Stamped
- An item’s own event time — what an
Overreach is located by. A history you cannot index by time is one you can only read at an assumed cadence, which is the bugHorizon::Overreplaces. - Symbolic
- A scalar-out node whose per-tick value is a pure
Exprof its deps, each read at itsFlatscalar. Earns thePurekernel, which is the whole of how it computes: there is no second way to state the value, so the algebra is load-bearing. - Unflat
Flat’s inverse: an item rebuilt from the slots a per-element kernel computed, plus the event time. The time is the kernel’s to carry rather than a slot, because a slot is a differentiation variable and an index may not be one (r[kernels.selection.index-is-not-a-variable]).- Wired
- What a cell reads, stated once. Every trait a node is written through — the body traits,
NodeandEmit— names this as a supertrait rather than declaring aDepsof its own, because a node has one edge set however its body is spelled. Two declarations could disagree, and theNode<Deps = N::Deps>equality bound that used to hold them together was that same statement restated once per kernel. - Witness
- Whether a reading is being watched. A type parameter rather than a flag, so the compute path
monomorphizes the recording away entirely —
kernel_cost’sscan == rawis the check that it did. Sealed: both answers are the engine’s. - Zipf
Spec - The exponent of a
Zipf— a number an app reading it from a config file has no const to give.
Functions§
- abs
- absent
- How a body inside the algebra declines, which the out plane reads back as absence
(
r[impl outs.absence.typed]). Every tree reaching one carriesExpr::MAYBE, so the operators that cannot answer over one refuse it where it is written rather than where it lands. - closed_
by - The prefix of a slower series that has closed by
deadline— the cross-rate read a node clocked by a faster series makes against atrading_data_dag::Bufferingdep. ATailand not a slice: the cut hides however many elements stand past the deadline, and a pick inside it still has to report its lag against the column it lands in. - constant
- exp
- gt
l > risr < l: one comparison in the algebra, read from the other side.- lt
- A comparison is the one thing an absence has no answer for, so a tree that can carry one may not
reach here:
orit against a number first, or leave the comparison out and let the absence propagate (r[impl outs.absence.typed]). - max
- min
- or
xwhere it stands,fallbackwhere it declines. The way out of absence: what comes back is a number exactly as often asfallbackis one, which is what lets a body compare it.- powi_of
- present
1.0wherexis a number,0.0where it declines — how a body reads an absence instead of merely carrying one. Flat, and never absent itself, so it is a condition the comparing operators accept.- read_mc
- Bounds are
Ts<Local>: market cap has no venue event time, so this lane’s axis is our clock. - read_oi
- read_
trades - required_
lanes - The source lanes a graph requires: maps its
Roots::required_eventsTypeIds toLaneKinds. Lives here — the dag stays storage-free, and persistence can’t see graph types — so it’s the one point that knows both an event’sTypeIdand its lane. An unknown event panics. - select
- The condition may not decline — a
Selectis where a body writes an absence, and a branch that cannot be chosen is no branch. The two branches stay permissive, which is the whole point. - sqrt
- square
- sum
Type Aliases§
- DepOuts
- Uniform binder-correct dep-tuple type wherever a signature hands a node its pulled deps
(concrete types there hit E0195). One alias rather than one per trait:
Wiredis the only place aDepsis declared, so there is only one projection to name. - DepReads
DepOutsat their positions — what a per-element kernel’sreadselects off.- Trigger
Out - Binder-correct trigger-out type for
Episodic::armsimpls — the arm-sideDepOuts. Writing the concrete type hits E0195 whenever the trigger’s out carries no lifetime of its own. - Unix
Nanos
Attribute Macros§
Derive Macros§
- Item
- The out plane’s four mechanical readings of one field list:
Flat,Bump,Stamped, andUnflatwhere the slots carry the whole item.