component-wise max — causal happens-before tracking
"""
return [
{"type": "ORSet", "sub": "Observed-Remove Set", "color": "#bc8cff", "icon": _ICONS["union"], "output": orset_out, "html_output": orset_html},
{"type": "LWWRegister", "sub": "Last-Write-Wins Register", "color": "#58a6ff", "icon": _ICONS["edit"], "output": lww_out, "html_output": lww_html},
{"type": "GCounter", "sub": "Grow-Only Distributed Counter", "color": "#3fb950", "icon": _ICONS["arrow-up"], "output": gc_out, "html_output": gc_html},
{"type": "VectorClock", "sub": "Causal Ordering", "color": "#f9a825", "icon": _ICONS["git-branch"], "output": vc_out, "html_output": vc_html},
]
except Exception as exc:
print(f" ⚠ CRDT demo failed ({exc}); using static fallback")
return []
def _load_domains() -> list[dict]:
"""Run `muse domains --json` and return parsed output."""
try:
result = subprocess.run(
[sys.executable, "-m", "muse", "domains", "--json"],
capture_output=True,
text=True,
cwd=str(_ROOT),
timeout=15,
)
if result.returncode == 0:
raw = result.stdout.strip()
data: list[dict] = json.loads(raw)
return data
except Exception:
pass
# Fallback: static reference data
return [
{
"domain": "music",
"active": "true",
"capabilities": ["Typed Deltas", "Domain Schema", "OT Merge"],
"schema": {
"schema_version": "1",
"merge_mode": "three_way",
"description": "MIDI and audio file versioning with note-level diff and semantic merge",
"dimensions": [
{"name": "melodic", "description": "Note pitches and durations over time"},
{"name": "harmonic", "description": "Chord progressions and key signatures"},
{"name": "dynamic", "description": "Velocity and expression curves"},
{"name": "structural", "description": "Track layout, time signatures, tempo map"},
],
},
}
]
# ---------------------------------------------------------------------------
# Scaffold template (shown in the "Build in 3 steps" section)
# ---------------------------------------------------------------------------
_TYPED_DELTA_EXAMPLE = """\
# muse show --json (any commit, any domain)
{
"commit_id": "b26f3c99",
"message": "Resolve: integrate shared-state (A+B reconciled)",
"operations": [
{
"op_type": "ReplaceOp",
"address": "shared-state.mid",
"before_hash": "a1b2c3d4",
"after_hash": "e5f6g7h8",
"dimensions": ["structural"]
},
{
"op_type": "InsertOp",
"address": "beta-a.mid",
"after_hash": "09ab1234",
"dimensions": ["rhythmic", "dynamic"]
}
],
"summary": {
"inserted": 1,
"replaced": 1,
"deleted": 0
}
}"""
_SCAFFOLD_SNIPPET = """\
from __future__ import annotations
from muse.domain import (
MuseDomainPlugin, LiveState, StateSnapshot,
StateDelta, DriftReport, MergeResult, DomainSchema,
)
class GenomicsPlugin(MuseDomainPlugin):
\"\"\"Version control for genomic sequences.\"\"\"
def snapshot(self, live_state: LiveState) -> StateSnapshot:
# Serialize current genome state to a content-addressable blob
raise NotImplementedError
def diff(self, base: StateSnapshot,
target: StateSnapshot) -> StateDelta:
# Compute minimal delta between two snapshots
raise NotImplementedError
def merge(self, base: StateSnapshot,
left: StateSnapshot,
right: StateSnapshot) -> MergeResult:
# Three-way merge — surface conflicts per dimension
raise NotImplementedError
def drift(self, committed: StateSnapshot,
live: LiveState) -> DriftReport:
# Detect uncommitted changes in the working state
raise NotImplementedError
def apply(self, delta: StateDelta,
live_state: LiveState) -> LiveState:
# Reconstruct historical state from a delta
raise NotImplementedError
def schema(self) -> DomainSchema:
# Declare dimensions — drives diff algorithm selection
raise NotImplementedError
"""
# ---------------------------------------------------------------------------
# SVG icon library — Lucide/Feather style, stroke="currentColor", no fixed size
# ---------------------------------------------------------------------------
def _icon(paths: str) -> str:
"""Wrap SVG paths in a standard icon shell."""
return (
'"
)
_ICONS: dict[str, str] = {
# Domains
"music": _icon(''),
"genomics": _icon(''),
"cube": _icon(''),
"trending": _icon(''),
"atom": _icon(''),
"plus": _icon(''),
"activity": _icon(''),
"pen-tool": _icon(''),
# Distribution
"terminal": _icon(''),
"package": _icon(''),
"globe": _icon(''),
# Engine capabilities
"code": _icon(''),
"layers": _icon(''),
"git-merge": _icon(''),
"zap": _icon(''),
# MuseHub features
"search": _icon(''),
"lock": _icon(''),
# CRDT primitives
"union": _icon(''),
"edit": _icon(''),
"arrow-up": _icon(''),
"git-branch": _icon(''),
# OT scenario outcome badges
"check-circle":_icon(''),
"x-circle": _icon(''),
}
# ---------------------------------------------------------------------------
# Planned / aspirational domains
# ---------------------------------------------------------------------------
_PLANNED_DOMAINS = [
{
"name": "Genomics",
"icon": _ICONS["genomics"],
"status": "planned",
"tagline": "Version sequences, variants, and annotations",
"dimensions": ["sequence", "variants", "annotations", "metadata"],
"color": "#3fb950",
},
{
"name": "3D / Spatial",
"icon": _ICONS["cube"],
"status": "planned",
"tagline": "Merge spatial fields, meshes, and simulation frames",
"dimensions": ["geometry", "materials", "physics", "temporal"],
"color": "#58a6ff",
},
{
"name": "Financial",
"icon": _ICONS["trending"],
"status": "planned",
"tagline": "Track model versions, alpha signals, and risk state",
"dimensions": ["signals", "positions", "risk", "parameters"],
"color": "#f9a825",
},
{
"name": "Scientific Simulation",
"icon": _ICONS["atom"],
"status": "planned",
"tagline": "Snapshot simulation state across timesteps and parameter spaces",
"dimensions": ["state", "parameters", "observables", "checkpoints"],
"color": "#ab47bc",
},
{
"name": "Your Domain",
"icon": _ICONS["plus"],
"status": "yours",
"tagline": "Six methods. Any multidimensional state. Full VCS for free.",
"dimensions": ["your_dim_1", "your_dim_2", "..."],
"color": "#4f8ef7",
},
]
# ---------------------------------------------------------------------------
# Distribution model description
# ---------------------------------------------------------------------------
_DISTRIBUTION_LEVELS = [
{
"tier": "Local",
"icon": _ICONS["terminal"],
"title": "Local plugin (right now)",
"color": "#3fb950",
"steps": [
"muse domains --new <name>",
"Implement 6 methods in muse/plugins/<name>/plugin.py",
"Register in muse/plugins/registry.py",
"muse init --domain <name>",
],
"desc": "Works today. Scaffold → implement → register. "
"Your plugin lives alongside the core.",
},
{
"tier": "Shareable",
"icon": _ICONS["package"],
"title": "pip-installable package (right now)",
"color": "#58a6ff",
"steps": [
"Package your plugin as a Python module",
"pip install git+https://github.com/you/muse-plugin-genomics",
"Register the entry-point in pyproject.toml",
"muse init --domain genomics",
],
"desc": "Share your plugin as a standard Python package. "
"Anyone with pip can install and use it.",
},
{
"tier": "MuseHub",
"icon": _ICONS["globe"],
"title": "Centralized registry (coming — MuseHub)",
"color": "#bc8cff",
"steps": [
"musehub publish muse-plugin-genomics",
"musehub search genomics",
"muse init --domain @musehub/genomics",
"Browse plugins at musehub.io",
],
"desc": "MuseHub is a planned centralized registry — npm for Muse plugins. "
"Versioned, searchable, one-command install.",
},
]
# ---------------------------------------------------------------------------
# HTML template
# ---------------------------------------------------------------------------
def _render_capability_card(cap: dict) -> str:
color = cap["color"]
body = (
cap["html_output"]
if "html_output" in cap
else f'
{cap["output"]}
'
)
return f"""
{cap['icon']} {cap['type']}
{cap['sub']}
{body}
"""
def _render_domain_card(d: dict) -> str:
domain = d.get("domain", "unknown")
active = d.get("active") == "true"
schema = d.get("schema", {})
desc = schema.get("description", "")
dims = schema.get("dimensions", [])
caps = d.get("capabilities", [])
cap_html = " ".join(
f'{c}'
for c in caps
)
dim_html = " · ".join(
f'{dim["name"]}' for dim in dims
)
status_cls = "active-badge" if active else "reg-badge"
status_text = "● active" if active else "○ registered"
dot = '' if active else ""
short_desc = desc[:150] + ("…" if len(desc) > 150 else "")
return f"""
{status_text}{domain}
{dot}
{short_desc}
{cap_html}
Dimensions: {dim_html}
"""
def _render_planned_card(p: dict) -> str:
dims = " · ".join(f'{d}' for d in p["dimensions"])
cls = "planned-card yours" if p["status"] == "yours" else "planned-card"
return f"""
{p['icon']}
{p['name']}
{p['tagline']}
{dims}
{'Build it →' if p["status"] == "yours" else 'coming soon'}
"""
def _render_dist_card(d: dict) -> str:
steps = "".join(
f'
{s}
' for s in d["steps"]
)
return f"""
{d['icon']}
{d['tier']}
{d['title']}
{d['desc']}
{steps}
"""
def render(output_path: pathlib.Path) -> None:
"""Generate the domain registry HTML page."""
print(" Loading live domain data...")
domains = _load_domains()
print(f" Found {len(domains)} registered domain(s)")
print(" Computing live CRDT demos...")
crdt_demos = _compute_crdt_demos()
active_domains_html = "\n".join(_render_domain_card(d) for d in domains)
planned_html = "\n".join(_render_planned_card(p) for p in _PLANNED_DOMAINS)
dist_html = "\n".join(_render_dist_card(d) for d in _DISTRIBUTION_LEVELS)
crdt_cards_html = "\n".join(_render_capability_card(c) for c in crdt_demos)
html = _HTML_TEMPLATE.replace("{{ACTIVE_DOMAINS}}", active_domains_html)
html = html.replace("{{PLANNED_DOMAINS}}", planned_html)
html = html.replace("{{DIST_CARDS}}", dist_html)
html = html.replace("{{SCAFFOLD_SNIPPET}}", _SCAFFOLD_SNIPPET)
html = html.replace("{{TYPED_DELTA_EXAMPLE}}", _TYPED_DELTA_EXAMPLE)
html = html.replace("{{CRDT_CARDS}}", crdt_cards_html)
html = html.replace("{{DIFF_ALGEBRA}}", _DIFF_ALGEBRA_HTML)
# Inject SVG icons into template placeholders
_ICON_SLOTS: dict[str, str] = {
"MUSIC": _ICONS["music"],
"GENOMICS": _ICONS["genomics"],
"CUBE": _ICONS["cube"],
"TRENDING": _ICONS["trending"],
"ATOM": _ICONS["atom"],
"PLUS": _ICONS["plus"],
"ACTIVITY": _ICONS["activity"],
"PEN_TOOL": _ICONS["pen-tool"],
"CODE": _ICONS["code"],
"LAYERS": _ICONS["layers"],
"GIT_MERGE": _ICONS["git-merge"],
"ZAP": _ICONS["zap"],
"GLOBE": _ICONS["globe"],
"SEARCH": _ICONS["search"],
"PACKAGE": _ICONS["package"],
"LOCK": _ICONS["lock"],
"CHECK_CIRCLE": _ICONS["check-circle"],
"X_CIRCLE": _ICONS["x-circle"],
}
for slot, svg in _ICON_SLOTS.items():
html = html.replace(f"{{{{ICON_{slot}}}}}", svg)
output_path.write_text(html, encoding="utf-8")
size_kb = output_path.stat().st_size // 1024
print(f" HTML written ({size_kb}KB) → {output_path}")
# Also write as index.html so the domain registry IS the landing page.
index_path = output_path.parent / "index.html"
index_path.write_text(html, encoding="utf-8")
print(f" Landing page mirrored → {index_path}")
# ---------------------------------------------------------------------------
# Diff Algebra section — five algorithm visualizations + StructuredDelta flow
# ---------------------------------------------------------------------------
_DIFF_ALGEBRA_HTML = """
Diff Algebra
Five Algebras. One Typed Result.
The engine selects the algorithm per dimension from your plugin’s
schema(). You declare the shape — the engine handles identity,
diffing, and merge selection automatically.
Identity is hash-based: two elements are equal iff their SHA-256 hashes match — content is never inspected by the core. Delete + insert pairs sharing the same hash are collapsed into MoveOps in a post-pass.
TreeZhang-Shasha / GumTree
scene graphs · ASTs · track hierarchies
Edit distance over node hierarchy — moves preserve subtree identity across parent changes.
Configurable ε threshold. Sparse mode records only changed blocks — efficient for large tensors.
SetSet algebra · add / remove
annotations · tags · gene ontology terms
before
GO:0001234GO:0005634GO:0006915GO:0016020
—
—
× del
—
+ ins
after
GO:0001234GO:0005634GO:0016020GO:0042592
Unordered — no position tracking. Pure membership delta: {removed} and {added}.
MapRecursive key-by-key delegation
metadata · configs · nested structures
tempo120 → 140scalar → PatchOp
notes[…] → […′]sequence → LCS
tags{…} → {…′}set → algebra
author"Bach" = "Bach"unchanged
Each key is diffed by whichever algorithm matches its declared type — recursively, to arbitrary depth.
diff() → StructuredDeltaall five algorithms produce the same typed operation list
InsertOpDeleteOpMoveOpReplaceOpPatchOp
merge_mode: “three_way”
Operational Transformation — independent ops commute automatically; conflicting ops surface for human resolution
or
merge_mode: “crdt”
CRDT join() — convergent, no coordination required; any two replicas always reach the same state
"""
# ---------------------------------------------------------------------------
# Large HTML template
# ---------------------------------------------------------------------------
_HTML_TEMPLATE = """\
Muse — Version Anything
muse
Version Anything
One protocol. Any domain. Six methods between you and a
complete version control system — branching, merging, conflict resolution,
time-travel, and typed diffs — for free.
Every domain — music, genomics, 3D spatial, financial models — implements
the same six-method protocol. The core engine handles
everything else: content-addressed storage, DAG, branches, log, merge base,
cherry-pick, revert, stash, tags.
6methods to implement
14CLI commands, free
∞domains possible
0core changes needed
Method
Signature
Purpose
snapshot
snapshot(live) → StateSnapshot
Capture current state as a content-addressable blob
diff
diff(base, target) → StateDelta
Compute minimal change between two snapshots (added · removed · modified)
merge
merge(base, left, right) → MergeResult
Three-way reconcile divergent state lines; surface conflicts per dimension
drift
drift(committed, live) → DriftReport
Detect uncommitted changes between HEAD and working state
apply
apply(delta, live) → LiveState
Apply a delta during checkout to reconstruct historical state
schema
schema() → DomainSchema
Declare data structure — drives diff algorithm selection per dimension
{{DIFF_ALGEBRA}}
Engine Capabilities
What Every Plugin Gets for Free
The core engine provides four advanced capabilities that any domain plugin
can opt into. Implement the protocol — the engine does the rest.
{{ICON_CODE}} Typed Delta Algebra
StructuredDelta — every change is a typed operation
Unlike Git's blob diffs, Muse deltas are typed objects:
InsertOp, ReplaceOp, DeleteOp — each
carrying the address, before/after hashes, and affected dimensions.
Machine-readable with muse show --json.
Each plugin's schema() method declares its dimensions and merge mode.
The engine uses this to select the right diff algorithm per dimension and to
surface only the dimensions that actually conflict.
{{ACTIVE_DOMAINS}}
{{ICON_GIT_MERGE}} OT Merge
Operational transformation — independent ops commute automatically
Plugins implementing StructuredMergePlugin get operational
transformation. Operations at different addresses commute automatically —
only operations on the same address with incompatible intent surface a conflict.
Scenario AIndependent ops at different addresses
leftInsertOp"ot-notes-a.mid"tick=0 · C4 E4 G4
rightInsertOp"ot-notes-b.mid"tick=480 · D4 F4 A4
transform → no overlap → ops commute{{ICON_CHECK_CIRCLE}} Clean merge · both files applied
Domains currently registered in this Muse instance. The active domain
is the one used when you run muse commit, muse diff,
and all other commands.
{{ACTIVE_DOMAINS}}
Ecosystem
The Plugin Ecosystem
Music is the reference implementation. These are the domains planned
next — and the slot waiting for yours.
{{PLANNED_DOMAINS}}
Distribution
How to Share Your Plugin
Three tiers of distribution — from local prototype to globally searchable
registry. Start local, publish when ready.
{{DIST_CARDS}}
{{ICON_GLOBE}}
MuseHub is coming
A centralized, searchable registry for Muse domain plugins —
think npm or crates.io, but for any multidimensional versioned state.
One command to publish. One command to install.