# Memeroot Composable XML Substrate

`MEMEROOT-SUB-COMPOSABLE-2026-001`

Eight block kinds. One spine. Zero crossover.

## What this is

A composable XML substrate carrying the production `TABLE_SPECIFICATIONS` /
`MBI_SCRIPT_AS_TABLE_SPEC_V` pattern out of SQL into pure XML/XSL. Eight
fundamental block kinds — data, schema, script, process, type, view,
identity, address — each in its own XML namespace, with absolutely no
crossover between kinds. Each block projects to the universal spine shape
via its own XSL stylesheet. The spine is computed from federation, never
stored.

## Structure

```
.
├── README.md                    this file
├── reference.html               architectural reference document
├── blocks/                      8 example block instances (one per kind)
├── xsl/                         8 per-kind projection stylesheets
├── spine/
│   ├── projection-shape.xml     canonical row shape declaration
│   └── table-specifications.xsl universal absorbing stylesheet
└── composition/
    ├── composition.xml          example unit definition
    ├── compile.js               dispatcher (Node.js)
    └── compiled-unit.spine.xml  output of the example compilation
```

## Quick start

```bash
node composition/compile.js
# compiles composition.xml → compiled-unit.spine.xml (43 rows from 8 blocks)
```

## Open the reference

```bash
open reference.html
# the architectural reference in the Memeroot dark forensic style
```

## The principles

1. **Zero crossover** — a data block contains no scripts; a script block contains
   no data; an identity block contains no signatures (those live on the signed
   artifact). Each block has a single concern.

2. **Per-kind projection** — every block kind has its own XSL stylesheet that
   projects it to the spine shape. The projector is pure: input XML in the
   block's namespace, output XML in the spine namespace, no side effects.

3. **Spine as computed view** — the `TABLE_SPECIFICATIONS` spine is the UNION
   of per-kind projections. It is recomputed on every invocation, never stored.
   This is the no-replication principle made operational.

4. **MPP-friendly by construction** — because blocks have zero crossover and
   projectors are pure, every block's projection runs as an independent process.
   Composition with 1,000 blocks compiles via 1,000 independent processes.

5. **Self-describing recursion** — a schema block can describe the spine's
   columns; the spine projects the schema block; the result describes itself.
   Bounded because blocks never embed blocks; references resolve at compile time.

## Lineage

Direct descent from the production `MBI_SCRIPT_AS_TABLE_SPEC_V` Oracle view,
deployed across Aviva, Marsh, ABN AMRO, Sanofi, Smith & Nephew, SEB, Cembra,
Greene King and others over the past twenty-five years. The substrate carries
that pattern out of SQL into XML so it applies to any environment — file
systems, object stores, regulated archives, federated networks.

Companion documents:
- `MEMEROOT-REF-2026-001` — Oracle Free Framework specification
- `MEMEROOT-OPS-PLAYBOOK-2026-001` — Operations Playbook

## License

Open for use by Memeroot operators. Redistribute with publisher signatures
intact.

— Memeroot Ltd · Rob Anderson · York · May 2026