Every table, in one place.

This page is the lookup surface for WRL Core 0.1.2 — the exact vocabularies, signatures, bounds, codes and pinned ids that the canonicalizer enforces. Prose lives in the guide; the normative text lives in the spec.

Grammar

The complete core world surface. Whitespace outside tokens is insignificant. Comments start with ; and run to end of line.

document    ::= profile-line  ( declaration | edge | comment | blank )*

profile-line ::= "profile" WS profile-id
declaration  ::= "[" role ":" id "]" [ config ] [ ports ]
edge         ::= "[" [ role ":" ] id "]" "--" edge-tag "-->" "[" [ role ":" ] id "]"

config       ::= "(" [ config-item ( "," config-item )* ] ")"
ports        ::= "{" [ port ( "," port )* ] "}"
config-item  ::= key "=" value | clock-sugar | "configurable"

role         ::= "pulser" | "relay" | "door" | "spinner" | "orb"
edge-tag     ::= "sig" | "socket"
id           ::= WORD  ; [A-Za-z0-9_]+, and MUST NOT contain "__"
comment      ::= ";" ANY*

Line regexes, as implemented

The role prefix is optional on an edge endpoint and, when present, is not part of the identity — [relay:r0] and [r0] refer to the same object on an edge line, and seal identically.

Role registry

The state schema reference is derived, never written: state.<role lowercased>.v1.

Port signatures

Frozen per role. The {…} group on a declaration is checked against this table, not defined by it.

Edge kinds

Legal source roles and destination roles fall out of the port table:

Configuration schema

The Pulser is the one role whose surface keys and canonical keys differ: four surface fields collapse into a single typed clock tuple.

Spinner fields

Rotor lanes are written with dots in the core surface (181.0.0.181). Because the dot is the lane separator, a rotor cannot carry a decimal fraction — rotor=181.5.0.0 is the four-lane rotor (181, 5, 0, 0), not a fractional value. The bootstrap surface used commas; that spelling is a legacy path.

Clock vocabulary

A clock outside its legal range is WRL_CLOCK_RANGE: period must be at least 1, phase must be less than period, and epoch must be non-negative.

Rotor vocabulary

Named rotors split into two classes, and the distinction is recorded in build provenance.

where u = 1 << n. Any other name is WRL_UNSUPPORTED_FEATURE.

The exact-integer projection

No floating point is used anywhere. round(u/√2) is computed with integer arithmetic only:

u      = 1 << n
two_uu = 2 * u * u
q0     = isqrt(two_uu) / 2
q      = q0 + 1   when  two_uu > 4*q0*q0 + 4*q0 + 1
       = q0       otherwise

A rounded named rotor carries the provenance policy forge_named_rotor_rne_sym_v1. Exact named rotors carry none. Provenance never enters the artifact bytes — it records how a value was produced, not what the value is.

Sugar forms and bounds

Sugar version sugar.v2. A source-to-source pre-pass in front of the untouched canonical parser.

Three decisions worth knowing: replication members are zero-based; replicated edges pair positionally and require equal counts on both sides; an inline comment on a replicated line attaches to the first emitted line.

Canonical artifact

The canonicalizer produces this record, serializes it as JSON with sorted keys and separators "," / ":" and no whitespace, then takes SHA-256 of the UTF-8 bytes.

{
  "ir_version": "1.0",
  "profile_id": "forge.world.core.v1",
  "objects": [
    { "object_id", "role", "ports", "state_schema_ref", "static_config" }, …
  ],
  "edges": [ { "src", "dst", "kind" }, … ],
  "schemas": {
    "runtime_state_schema": "RuntimeStateV1",
    "epoch_input_schema":  "EpochInputV1",
    "observable_schema":   "EpochResultV1"
  },
  "semantic_policies": {
    "rulepack_id":       "forge.world.core.rules.v1",
    "admit_policy_id":   "admit_candidate_min_firstreceipt_v1",
    "film_schema_id":    "film.v0.7",
    "numeric_policy_ids": ["POLICY_FORGE"]
  }
}

Canonical ordering

Because objects sort identity-first, the order you declare things in is inert: shuffling declaration lines cannot move the sem- id.

Pinned policy ids

Identity ladder

Every id is <prefix>-<64 lowercase hex>, SHA-256 over the canonical bytes of the thing named. Nothing else may occupy those namespaces.

The two sem- values used across this site — both asserted by test/conformance.mjs, so a build that disagrees with either is a failing build:

What moves an id, and what does not

Diagnostic codes

Every rejection is one of these typed codes. Downstream tools branch on the code; the detail string is for humans.

This is the full Forge toolchain catalog, not the list a single stage emits. The Browser column says whether the playground can raise the code at all: the browser spine stops at the seal, so codes belonging to backend lowering or to sealed-record round-tripping are listed for completeness and will never appear there. The subset is available programmatically as W.BROWSER_CODE_IDS, and test/conformance.mjs checks that every code in it has a description and that the two lists have not drifted apart.

A diagnostic carries a code, a human detail, and — where the failure is lexical — a line number in the authored source, mapped back through any sugar expansion so it refers to what you wrote rather than to generated text. When the fault lies inside an expansion, the diagnostic also reports which member of the expansion it was.

Parser entry points

Two forbidden tokens mark a world document as containing run inputs: a line beginning periods , and a line containing [epoch:.

Status: three axes, not one tier

An earlier revision of this site described every construct with a single "tier". That word was doing three unrelated jobs at once, and it hid the exact thing a reader most needs to know. Frozen meaning and writable syntax are independent. The period cycle is completely settled and you cannot type it; surface sugar is fully writable and deliberately not frozen. A single scale cannot say both, so this site uses three.

Where each construct sits today

Counting the yes rows is the honest summary of the language as a writable artifact: containers, five roles, two edge kinds, the solid route texture, the sugar layer, the document boundary and the canonicalization that gives you an id. Everything else on this site is meaning you can rely on and syntax you cannot yet write.

Promotion capabilities

A capability is one named thing the toolchain does not do yet. It is the unit in which the future arrives.

This table is the registry, and it is machine-read. Every data-requires annotation in the published HTML must name a capability listed here; the conformance suite fails on an unknown name, on a capability missing either classification, and on a registry entry that nothing cites. A capability cannot be invented in a footnote, and it cannot be quietly abandoned.

Each row carries two independent classifications, and the difference between them is the difference between a design and a program:

The two textures below are why the second axis exists. Writing [p0] ~~sig~~> [r0] does not produce a syntax error. The parser recognizes the reserved texture — it does not fall through to "unrecognized notation" — so what comes back is located on line 4 and says why: these are transition classes, not IR v1 edges. That is more than "unshipped" and much less than "shipped".

The Step column is the position in the dependency ladder. Steps are a partial order, not a schedule: several capabilities share a step because nothing among them blocks the others.

Browser API

wrl.js is an ES module: a faithful browser port of the identity spine, verified against the reference implementation's canonical bytes. It is what the playground runs, which is why the ids it shows are real.

import * as W from "./wrl.js";

const r = await W.sealWorld(source);
// { ok: true,  source, desugared, origins, graph, artifact, bytes,
//   semanticId: "sem-…", sugared }
// { ok: false, code, message, line, locator, fieldPath }

Errors are thrown as WrlError carrying code, detail, line, locator and fieldPath. sealWorld catches them and returns them as data.