Crate beck_core 

Types, Core, placement and splitting — stages 4 through 8 of §4.1’s pipeline.

 4 Resolve    modules, imports, name binding, hygiene scopes
 5 Typecheck  HM → typed AST
 6 Lower      desugar to CORE
 7 PLACE      ◀── the product.  every Core node carries a tier
 8 Split      partition Core per tier; SYNTHESISE boundaries

Stages 4–6 are one pass (check) because §4.2 permits three IRs and no more: a separate resolved-but-untyped tree would be a fourth. Stages 7 and 8 are place and split, which §4.1 calls out as “novel … where the engineering budget goes”.

Re-exports

pub use backend::Backend;

pub use backend::Callable;

pub use backend::ExecError;

pub use bundle::Bundle;

pub use check::check_module;

pub use check::Def;

pub use check::Program;

pub use check::SignalDecl;

pub use compat::compare;

pub use compat::is_breaking;

pub use compat::Change;

pub use core::digest;

pub use core::Const;

pub use core::Core;

pub use core::CoreKind;

pub use core::Env;

pub use core::Prim;

pub use core::Value;

pub use core::VarId;

pub use diff::diff;

pub use diff::Op as DiffOp;

pub use diff::Path as DiffPath;

pub use graph::DepGraph;

pub use graph::EdgeKind;

pub use graph::GraphBuilder;

pub use graph::GraphNode;

pub use graph::NodeId;

pub use graph::NodeKind;

pub use html::Html;

pub use iface::Interface;

pub use place::Key;

pub use place::Lock;

pub use place::Method;

pub use place::Solution;

pub use pmap::PMap;

pub use project::compile_project;

pub use project::Sources;

pub use row::Ambient;

pub use row::Effect;

pub use row::Row;

pub use secure::sendable;

pub use secure::storable;

pub use secure::NotSendable;

pub use signal::Cut;

pub use signal::Graph as SignalGraph;

pub use signal::Op as SignalOp;

pub use signal::SigId;

pub use split::Placed;

pub use split::Roles;

pub use split::StateRole;

pub use testing::Clause;

pub use testing::Expectation;

pub use testing::TestDef;

pub use ty::Tier;

pub use ty::Ty;

pub use ty::TyDecl;

Modules

backend

The seam between Core and something that can execute it.

bundle

The compiled slice of one component, in the form a client can execute — Mode B’s payload.

check

Resolution and typechecking, elaborating straight into Core.

clock

Time, as a thing that is supplied rather than a thing that is ambient.

command

What a client may send, resolved once: the Command union as a decoder.

compat

beck check --wire-compat — boundary versioning, §4.3.

core

Core — the load-bearing IR, and the evaluator that runs it.

cost

The placement cost model — §3.4’s node costs, edge costs and byte estimates.

delta

The data patch: what a Mode B subscription carries instead of DOM patches.

diff

Structural diff of two Html values — the producer half of “the browser is fold(apply_patch, initial_html, patch_stream)”.

digest

Digests and the two encodings a digest is written in.

docgen

beck doc — a module’s reference documentation, derived from the module.

edge

The three values a host hands a pure program at the edge.

engine

The incremental view engine: the thing that flows deltas through a crate::plan::Plan.

fields

Where a record literal’s fields go, decided once instead of once per record.

frames

How many bindings a function body makes, so that a call can reserve room for them.

fuse

Query fusion: a plan rewritten into a smaller plan that computes the same thing.

gen

One type-directed value generator, used by three features.

graph

The dependency graph — what the program is made of and what depends on what.

html

Html as a value, not a string.

iface

.becki — the published module signature, and the separate-compilation firewall.

incremental

Which views can be maintained by delta, and which have to be recomputed — and why.

liveness

Which read of a local is its last one, so a backend may move the value instead of copying it.

net

Outbound HTTP, as a thing that is supplied rather than a thing that is ambient.

place

Stage 7 — placement: inferred from effects, solved against a cost model, verified.

plan

The view, as a dataflow plan rather than as one expression.

pmap

A persistent ordered map — the language’s Map[K, V].

prelude

The standard library of the walking skeleton.

project

Multi-module compilation: check against signatures, then link.

read

The read model: a program’s maintained state as relations, and a small SQL over them.

render

Where a component renders — the Mode A / Mode B decision, and what it costs to be wrong.

repr

The storable shape of a Value, and the binary encoding of it.

row

Effect rows — §3.2, made real.

secure

§3.5’s security properties, as checks rather than as intentions.

signal

The signal graph, as a graph.

split

Stage 8 — signal-graph slicing, and the boundaries it synthesises.

stdlib

The standard library’s Beck half, carried inside the compiler.

testing

test and property blocks — docs/21-tests-in-beck-and-proof.md §21.2 and §21.3, checked.

ty

Types, effect rows, unification, and the tier lattice.

Functions

check_str

Parse, expand and check one source string, stopping before placement.

compile

The whole front end: parse, expand, check, place, split.

compile_or_library_str

The same, admitting a library: a module with no merge point comes back as a split::Placed whose roles are placeholders rather than as None.

compile_str

Compile one source string against a fresh source map. The shape every test uses.

compile_with

The same, against a previously solved placement — §3.4’s stability guardrail.