1282 lines
78 KiB
Markdown
1282 lines
78 KiB
Markdown
# Eve Migration Roadmap
|
|
|
|
Date: 2026-07-08
|
|
|
|
The great Eve migration is the move from a useful pile of renderer proofs,
|
|
fixtures, provider demos, and platform experiments into a kernel-shaped system:
|
|
Eve core owns contracts, plugins own semantics, runtime repos own native
|
|
projection, and provider repos own live truth.
|
|
|
|
This is not a repo cleanup campaign. It is an authority migration. The split is
|
|
complete only when the old in-repo convenience paths can no longer decide
|
|
provider truth, plugin semantics, or runtime behavior by accident.
|
|
|
|
## Objective
|
|
|
|
Make Eve the stable interactive language for CultMesh surfaces without turning
|
|
`E:\Projects\Eve` into a permanent warehouse.
|
|
|
|
The target shape:
|
|
|
|
- Eve core: surface contracts, CultUI DSL, command/binding descriptors,
|
|
provider/plugin advertisement specs, browser reference, and conformance
|
|
harness incubation.
|
|
- EvePlugins: first-party reusable semantic plugins while young.
|
|
- Owner repos: Sai owns VN/Ink, Norn owns graph semantics, providers such as
|
|
Aetheria own live state and authored product surfaces.
|
|
- Runtime repos: EveUnity, EveFlutter, EveAndroid, EveIOS, EveGodot, EveElectron,
|
|
Fensalir/Direct2D, and future bodies own projection, build glue, plugin
|
|
projection adapters, capture, and runtime tests.
|
|
- EveConformance: fixture corpus, parity runner, capability matrix,
|
|
screenshot/report artifacts, plugin packs, and CI once the harness is stable
|
|
enough to leave Eve core.
|
|
|
|
## Current Authority Map
|
|
|
|
Owner:
|
|
|
|
- Eve owns `gamecult.eve.surface.v1`, `gamecult.eve.command.v1`, CultUI,
|
|
provider/plugin advertisement contracts, plugin ABI shape, browser reference
|
|
behavior, and parity/conformance policy.
|
|
|
|
Inputs:
|
|
|
|
- Local fixtures under `web/fixtures`.
|
|
- Incubating plugin manifests under `plugins/incubating`.
|
|
- Runtime claims in `tools/parity/parity-manifest.json`.
|
|
- Provider advertisements such as Repixelizer's local fixture.
|
|
- Hermodr/Odin/CultMesh live provider surfaces when available.
|
|
|
|
Outputs:
|
|
|
|
- Browser reference lowering.
|
|
- Runtime capability reports.
|
|
- Plugin capability gaps.
|
|
- Parity reports under `artifacts/parity`.
|
|
- Split targets and graduation triggers in the parity manifest.
|
|
|
|
Derived state:
|
|
|
|
- Local provider lists are fixture advertisements, not discovery truth.
|
|
- Runtime capability status is diagnostic, not provider authority.
|
|
- Screenshot/golden artifacts are evidence, not portable state.
|
|
- In-repo runtime/plugin bodies are incubation, not permanent ownership.
|
|
|
|
Forbidden writers:
|
|
|
|
- Runtime lowerers must not import provider internals to recover missing
|
|
semantics.
|
|
- Plugins must not mutate provider truth or accept provider commands.
|
|
- Product demos must not become Eve core fixtures once they carry product state,
|
|
assets, receipts, or deployment assumptions.
|
|
- Compatibility HTTP routes and browser tabs must not replace provider
|
|
advertisements.
|
|
- Passing parity tests must not preserve a body that cannot name its owner,
|
|
inputs, outputs, and split trigger.
|
|
|
|
Shared paths:
|
|
|
|
- Every runtime claim flows through `tools/parity/parity-manifest.json`.
|
|
- Every fixture belongs to a conformance pack: `core`, `plugin`, `provider`, or
|
|
`runtime`.
|
|
- Every plugin claim names owner repo, split target, capabilities, required
|
|
fixtures, and graduation trigger.
|
|
- Every runtime claim names owner repo, repo role, split target, supported
|
|
features, plugin support, and graduation trigger.
|
|
|
|
Deletion line:
|
|
|
|
- Cut hardcoded provider tabs before adding new live providers.
|
|
- Cut renderer-specific product knowledge before claiming generic Eve support.
|
|
- Cut in-repo runtime/plugin bodies once their contract and release lifecycle
|
|
stop changing.
|
|
|
|
## Phase 0: Ledger And Contract Grounding
|
|
|
|
Status: underway.
|
|
|
|
Purpose: make ownership visible before moving code.
|
|
|
|
Work:
|
|
|
|
- Keep `docs/repo-strategy.md` as the repo boundary doctrine.
|
|
- Keep this roadmap as the migration sequence.
|
|
- Keep `tools/parity/parity-manifest.json` as the machine-readable ownership
|
|
ledger.
|
|
- Keep `docs/surface-contract-v1.md`,
|
|
`docs/provider-advertisement-contract.md`, and
|
|
`docs/plugin-architecture.md` as the contract source of truth.
|
|
- Keep browser reference and parity harness green after every migration cut.
|
|
|
|
Exit criteria:
|
|
|
|
- All fixtures declare a conformance pack.
|
|
- All incubating plugins declare owner, split target, capabilities, and required
|
|
fixtures.
|
|
- All runtimes declare owner, repo role, supported features, plugin claims, and
|
|
graduation trigger.
|
|
- Harness reports missing ownership metadata and plugin gaps explicitly.
|
|
|
|
Current proof:
|
|
|
|
- `node --test web\eve-dsl.test.mjs`
|
|
- `powershell -ExecutionPolicy Bypass -File .\scripts\run-parity-harness.ps1`
|
|
|
|
## Phase 1: Stabilize Core Surface Contract
|
|
|
|
Purpose: make the surface contract boring enough that runtimes and providers can
|
|
leave the repo without dragging hidden behavior with them.
|
|
|
|
Work:
|
|
|
|
- Normalize `surface.root`, `surface.styles.tokens`, `stateBindings`,
|
|
`embeddedDocuments`, command templates, and operation invocation descriptors.
|
|
- Keep compatibility fields such as `nodes`, `selectedNodeId`, raw `command`,
|
|
and string payloads as projections only.
|
|
- Add explicit authority/staleness witness UI in the browser reference for
|
|
stale, missing, predicted, denied, accepted, and reconciled values.
|
|
- Add provider advertisement fixture checks for local and live discovery paths.
|
|
First cut is in place for Repixelizer and Aetheria provider advertisements.
|
|
- Add plugin advertisement fixture checks before adding more plugin semantics.
|
|
|
|
Exit criteria:
|
|
|
|
- Browser reference can open all local fixtures through advertisement-shaped
|
|
provider entries.
|
|
- New renderer APIs construct commands from CultMesh operation descriptors, not
|
|
raw strings.
|
|
- New binding APIs carry CultMesh state binding descriptors, not renderer-local
|
|
stores.
|
|
- Parity harness fails if embedded slots, required bindings, command descriptors,
|
|
or provider advertisement fields disappear.
|
|
|
|
## Phase 2: Split Conformance Shape From Runtime Bodies
|
|
|
|
Purpose: make the evidence path portable before runtime repos leave.
|
|
|
|
Work:
|
|
|
|
- Promote `tools/parity` from a local script into a conformance pack layout:
|
|
fixture metadata, expected capability matrix, runtime adapters, plugin packs,
|
|
and report schema.
|
|
- Separate core fixtures from plugin/provider/runtime fixtures.
|
|
- Add screenshot comparison metrics for structure, token colors, bounding boxes,
|
|
text presence, and capability-gap overlays without pretending byte-identical
|
|
pixels are the goal.
|
|
- Keep generated reports under `artifacts/parity` as evidence only.
|
|
|
|
Exit criteria:
|
|
|
|
- A runtime repo can run conformance against Eve fixtures without importing Eve
|
|
source internals.
|
|
- Plugin conformance packs can be added without editing core harness logic.
|
|
- `EveConformance` has a clean split plan, or stays incubating only because the
|
|
report schema is still changing.
|
|
|
|
## Phase 3: Graduate Plugins
|
|
|
|
Purpose: move semantic ownership out of Eve core.
|
|
|
|
Work:
|
|
|
|
- Keep `plugins/incubating/sai-vn.plugin.json`,
|
|
`plugins/incubating/norn-graph.plugin.json`, and
|
|
`plugins/incubating/tex-math.plugin.json` as temporary manifests.
|
|
- Define `gamecult.eve.plugin.v1` and
|
|
`gamecult.eve.plugin_advertisement.v1` as explicit schemas. First-cut JSON
|
|
schemas live under `schemas/` and the parity harness validates incubating
|
|
plugin manifests and advertisements against them.
|
|
- Add plugin ABI fixtures for `describe`, `validate`, `project`, `apply`,
|
|
`lower`, and `measure` where relevant.
|
|
- Move `sai.vn` to Sai when VN/Ink story state, visual manifest, story commands,
|
|
and projection fixtures are stable.
|
|
- Move `norn.graph` to Norn when graph layout, interaction, fallback, and
|
|
conformance fixtures are stable.
|
|
- Move `tex.math` to EvePlugins when TeX source, macro, baseline, cached render,
|
|
and fallback fixtures are stable.
|
|
- Treat nested plugin placement as composition, not custody. A Sai surface may
|
|
deploy with nested Norn or TeX surfaces when those independent plugin
|
|
sidecars are available, but Sai does not depend on them for VN authority and
|
|
does not own their graph or math semantics. Norn and TeX keep their own ABI
|
|
manifests, capability claims, and conformance packs.
|
|
|
|
Exit criteria:
|
|
|
|
- Eve core knows plugin manifests and capability gaps, not plugin internals.
|
|
- Providers invoke plugins through the ABI object model.
|
|
- Runtimes declare plugin support through capability manifests.
|
|
- Unsupported required plugin capabilities appear as visible gaps.
|
|
- Optional nested plugin gaps degrade the nested surface; they do not transfer
|
|
graph, math, or renderer semantics into the parent plugin.
|
|
- A provider may mark a nested plugin slot as optional or required for a
|
|
specific surface, but that availability policy is provider composition, not
|
|
Sai ownership of Norn or TeX.
|
|
|
|
## Phase 4: Graduate Runtime Bodies
|
|
|
|
Purpose: let runtime repos own native projection without losing conformance.
|
|
|
|
Work:
|
|
|
|
- EveFlutter: provider picker, command transport, plugin projection adapters,
|
|
Android/iOS/desktop build flow, native capture, and parity reports.
|
|
- EveUnity: UPM package release, plugin projection adapter behavior,
|
|
resolver-backed embedded documents, Unity test/capture lifecycle, and Aetheria
|
|
consumption.
|
|
- EveAndroid: Kotlin device edge, generic surface traversal, sensor publishing,
|
|
Android-specific CI, and explicit discovery input.
|
|
- EveIOS: UIKit renderer, sensor edge release flow, fixed-device and simulator
|
|
capture, and generic surface lowering.
|
|
- Fensalir/Direct2D: Eve-to-`AquariumUiDocument` adapter, DirectWrite/Direct2D
|
|
token lowering, embedded slot preservation, and frame capture.
|
|
- EveWeb: stays in Eve while it is the behavior oracle; splits only if it becomes
|
|
an independently deployed runtime product.
|
|
|
|
Exit criteria:
|
|
|
|
- Runtime can build, test, capture, and report conformance without sharing Eve's
|
|
dirty worktree.
|
|
- Runtime consumes surface documents, plugin manifests, and provider
|
|
advertisements through contracts.
|
|
- Runtime has no provider-specific renderer brain unless it is explicitly a
|
|
provider-owned app.
|
|
|
|
## Phase 5: Move Product Fixtures To Provider Repos
|
|
|
|
Purpose: prevent demos from becoming quiet product authority inside Eve.
|
|
|
|
Work:
|
|
|
|
- Repixelizer owns job/session/artifact/operator fixtures once they carry real
|
|
product state or receipts.
|
|
- Aetheria owns RTS/ARPG world surfaces, daemon-published asset manifest
|
|
records, generated level state, command receipts, and scenario conformance.
|
|
- Huginn owns `.cc` and Persona-state inspection fixture packs when they depend
|
|
on runtime stewardship details.
|
|
- Mimir owns sensor/media/control surfaces that depend on live stream timing or
|
|
room state.
|
|
|
|
Exit criteria:
|
|
|
|
- Provider repo publishes provider advertisements and fixture/conformance packs.
|
|
- Eve core keeps only minimal generic fixtures and references provider packs by
|
|
contract.
|
|
- Product assets and receipts are not stored as Eve core truth.
|
|
|
|
## Phase 6: Cut Compatibility Paths
|
|
|
|
Purpose: make old routes unable to reassert authority.
|
|
|
|
Work:
|
|
|
|
- Remove hardcoded browser provider tabs once live/local advertisements cover
|
|
the same flows.
|
|
- Remove direct Mimir deck probing from generic Eve paths.
|
|
- Remove renderer-private style shortcuts once token lowering is complete.
|
|
- Remove raw command construction APIs from new public runtime paths.
|
|
- Remove provider-specific renderer fallbacks from generic lowerers.
|
|
|
|
Exit criteria:
|
|
|
|
- The only normal path is provider advertisement -> surface document -> runtime
|
|
lowering -> command intent -> provider receipt -> republished state.
|
|
- Compatibility routes exist only as named lowerings or debug probes.
|
|
- Parity and runtime diagnostics report the same layer of reality the user sees.
|
|
|
|
## Active Work Queue
|
|
|
|
1. Repoint Eve conformance and handoff evidence at the graduated `EveUnity`
|
|
owner repo, then delete the duplicate
|
|
`runtimes/incubating/eve-unity-scene` body and Eve-local Unity lifecycle
|
|
scripts. Keep only Eve contracts and cross-repo conformance policy here.
|
|
2. Add a real Unity PlayMode PNG/frame capture in EveUnity for Aetheria's
|
|
daemon-published game surface and the generic world-smoke provider.
|
|
3. Replace Aetheria's local state-file polling adapter with a generic live
|
|
CultMesh/CultNet provider transport when that transport contract is ready;
|
|
Aetheria should then supply only provider advertisement and credentials.
|
|
|
|
Recently cut:
|
|
|
|
- `GameCult/EveUnity` now exists as the runtime owner repo. It owns
|
|
`packages/org.gamecult.eve.unity-scene`, the generic GameObject playable-world
|
|
host, camera/input components, plugin projection shells, package tests, UPM
|
|
packing, and its authority map. Commit `9341d44` established the repo and
|
|
commit `862d2bd` made its Aetheria consumer runner resolve the package from
|
|
the owner path.
|
|
- Aetheria now consumes
|
|
`file:../EveUnity/packages/org.gamecult.eve.unity-scene` rather than Eve's
|
|
incubating runtime directory. Its provider-owned adapter remains under
|
|
`org.gamecult.aetheria.eve-runtime`; the generic lowerer no longer arrives
|
|
from the provider repo or Eve core. A consumer run through the owner path
|
|
passed all 21 `GameCult.Eve.UnityScene.Tests` tests, with results under
|
|
`E:\Projects\EveUnity\artifacts\aetheria-consumer\20260710T022930`.
|
|
- The runtime split is not yet structurally complete because Eve's parity
|
|
manifest, handoff ledger, and Unity smokes still inspect the incubating copy.
|
|
Those references must move to owner-repo evidence before the duplicate body
|
|
is deleted. Until that deletion, EveUnity is the active package owner and
|
|
Eve's copy is migration residue, not a second runtime authority.
|
|
- The web reference now has a schema-backed layout probe for the
|
|
`embedded-surface` and `sai-vn` fixtures.
|
|
`scripts/run-web-reference-layout-probe-smoke.ps1` builds the browser lowerer,
|
|
runs Chrome headless through
|
|
`tools/web-reference/run-layout-probe.mjs`, writes
|
|
`gamecult.eve.web_layout_probe.v1` evidence under
|
|
`artifacts/web-reference-layout-probe/latest/`, and parity consumes those
|
|
artifacts so `web:embedded-surface:bounding-boxes` and
|
|
`web:sai-vn:bounding-boxes` are measured runtime evidence instead of
|
|
`pending-runtime-probe`. This proves the browser oracle can measure both core
|
|
embedded slots and a Sai surface that optionally composes independent Norn
|
|
and TeX plugin surfaces without taking custody of their semantics.
|
|
- The conformance export now carries `screenshotComparisonMetrics[]` records.
|
|
Runtime owners get structure, color-token, bounding-box, and text-presence
|
|
metrics per runtime/fixture pair without relying on byte-identical screenshots
|
|
or Eve-local prose. Structure and token metrics are surface-contract evidence;
|
|
text presence is authored text evidence; bounding boxes stay
|
|
`pending-runtime-probe` or `pending-capture` until a runtime-owned capture or
|
|
layout probe attaches real visual evidence.
|
|
- Runtime capability manifests now declare world-surface lowering targets.
|
|
`web/eve-runtime-capability.json` claims `web-reference`, and
|
|
`packages/org.gamecult.eve.unity-uitoolkit/eve-runtime-capability.json`
|
|
claims `unity-uitoolkit`, each with supported world surface kinds,
|
|
projection kinds, support level, evidence paths, and the rule that runtimes
|
|
lower provider-owned world state without owning it. Parity compares those
|
|
claims against the ledger, exports them through runtime records and
|
|
`packs/runtime.json`, the runtime-owner smoke asserts them, and the generic
|
|
conformance smoke now treats `unity-scene`, `electron-shell`, and `tui` as
|
|
narrow runtime-owned command-surface claims while capture and release remain
|
|
split blockers.
|
|
- Missing provider-advertised world-surface lowering targets are still assigned
|
|
to their pending runtime owner when one exists. Eve only owns a world-lowering
|
|
gap when no runtime target has been declared.
|
|
- The conformance export now carries `worldSurfaceLoweringGaps[]` as typed
|
|
data in addition to the generic `capabilityGaps[]` ledger. Runtime owners can
|
|
consume provider id, surface id, target id, owner repo, runtime id, split
|
|
target, and runtime status without scraping prose or gap strings.
|
|
- The conformance export also carries `worldSurfaceLoweringCoverage[]`, a full
|
|
provider-surface-to-target ledger that marks each advertised lowering target
|
|
as `claimed`, `missing-claim`, or `missing-runtime`. The generic conformance
|
|
consumer now asserts Aetheria's claimed web, UI Toolkit, Unity scene graph,
|
|
Electron shell, and TUI terminal-grid targets from the same typed surface.
|
|
- The conformance export carries `commandBoundaryCoverage[]`, joining each
|
|
provider-owned interactive world surface target to its runtime owner,
|
|
provider command boundary, receipt schema, and runtime command envelope. Web,
|
|
Unity UI Toolkit, Unity scene, Electron shell, and TUI are `covered` because
|
|
they advertise `gamecult.eve.command.v1`.
|
|
- The browser reference lowerer now carries the active provider surface's
|
|
advertised `worldInteraction.commandBoundary` and
|
|
`worldInteraction.receiptSchema` into each `gamecult.eve.command.v1` intent.
|
|
It can use component action metadata as a fallback, but the provider
|
|
advertisement is the authority when present.
|
|
- The browser lowerer command intent path now passes the active surface id
|
|
explicitly and tests that a provider with multiple world surfaces uses the
|
|
active surface advertisement instead of the provider's first advertised
|
|
surface. This keeps Aetheria game/editor command boundaries from collapsing
|
|
inside the generic web reference.
|
|
- Unity scene now has a provider-shell contract skeleton under
|
|
`runtimes/incubating/eve-unity-scene`. The skeleton consumes an advertised
|
|
`worldInteraction` boundary, creates `gamecult.eve.command.v1` requests with
|
|
command boundary and receipt schema fields, builds a provider-agnostic Unity
|
|
scene graph DTO from the surface tree, and claims only the `unity-scene`
|
|
graph command-surface target. It still does not own provider simulation,
|
|
plugin projection adapters, release, or capture evidence.
|
|
- EveElectron now has a provider-shell contract skeleton under
|
|
`runtimes/incubating/eve-electron`. The shell selects advertised provider
|
|
surfaces, emits `gamecult.eve.command.v1` intents with provider command
|
|
boundary and receipt schema fields, and has a runnable Node smoke without
|
|
claiming embedded document rendering, packaged Electron lifecycle, or capture.
|
|
- EveTui now has a provider-shell contract skeleton under
|
|
`runtimes/incubating/eve-tui`. The shell selects advertised provider
|
|
surfaces, emits `gamecult.eve.command.v1` intents with provider command
|
|
boundary and receipt schema fields, lowers Eve surface trees into an
|
|
explicitly lossy `gamecult.eve.tui_grid.v1` terminal grid, and claims the
|
|
`tui` command-surface target without owning provider truth or transcript
|
|
capture.
|
|
- The conformance export carries `splitHandoffMoveCoverage[]`, joining runtime
|
|
split handoff move sets to source path status. EveElectron now exposes the
|
|
existing Aetheria `Aetheria.Rts.Web/Electron` and command transport paths as
|
|
`observed-provider` sources that must be replaced by a provider-agnostic
|
|
shell; Unity scene now exposes current incubation paths for its generic scene
|
|
graph body, world-surface lowering claim, and command transport, while scene
|
|
capture remains replacement-required.
|
|
- The conformance export schema and consumer smoke now require minimum typed
|
|
item shapes for plugins, providers, runtimes, and split targets. Owner repos
|
|
can rely on exported ids, owners, statuses, split targets, manifest or
|
|
advertisement paths, feature/plugin arrays, and blocker/proof arrays instead
|
|
of treating those sections as untyped bags.
|
|
- Plugin ABI fixture operations are now exported as
|
|
`plugins[].abiOperationContracts`. Sai and Norn can consume operation-level
|
|
`input` and `expect` contracts for `describe`, `validate`, `project`,
|
|
`lower`, `measure`, and `apply` without reading Eve-local fixture files.
|
|
- Plugin ABI operation coverage is now exported as root
|
|
`pluginAbiOperationCoverage[]` records. The plugin-owner smoke asserts Sai
|
|
Norn, and TeX `describe`, `lower`, and `apply` operations as `contracted`, so
|
|
plugin owners can consume the coverage ledger without walking Eve's nested
|
|
plugin records.
|
|
- Plugin handoff move/source coverage is now exported as root
|
|
`pluginHandoffMoveCoverage[]` records. The plugin-owner smoke asserts Sai,
|
|
Norn, and TeX manifest and ABI-conformance move sets as current existing
|
|
sources, so owner repos can see what must leave Eve incubation without
|
|
reading Eve's parity manifest or plugin handoff files directly.
|
|
- Provider/plugin requirement coverage is now exported as root
|
|
`providerPluginRequirementCoverage[]` records with availability. The
|
|
plugin-owner smoke asserts `sai.vn` as the required VN plugin and
|
|
`norn.graph` / `tex.math` as `optional-satisfied` nested plugins owned by
|
|
Norn and EvePlugins. A Sai surface can embed Norn or TeX when those plugins
|
|
are available, but Sai does not own their graph or math semantics.
|
|
- Runtime/plugin projection claims are now exported as root
|
|
`runtimePluginProjectionCoverage[]` records. Runtime-owner smokes assert
|
|
Unity UI Toolkit support for `sai.vn`, `norn.graph`, and `tex.math`, Unity
|
|
scene support for the same three plugin capabilities, and Electron shell
|
|
and TUI support for the same sidecar plugin projection shells without
|
|
importing plugin semantics.
|
|
- Provider/runtime/plugin projection coverage is now exported as
|
|
`providerRuntimePluginProjectionCoverage[]`. The runtime-owner smoke proves
|
|
the Sai VN provider surface lowers fully in web, lowers in Unity UI Toolkit
|
|
and Android Flutter with optional independent Norn and TeX nested plugin
|
|
projection when those plugins are available, and does not let UIKit's generic
|
|
embedded-document path impersonate required Sai VN, optional Norn graph, or
|
|
optional TeX math projection.
|
|
- Runtime/plugin projection gaps are now exported as
|
|
`runtimePluginProjectionGaps[]`. Device-edge runtimes no longer consume the
|
|
Sai fixture as failed projection clients; missing Sai, Norn, or TeX support is
|
|
recorded only on runtimes that actually claim plugin projection work, so plugin
|
|
semantics do not drift into Eve core or Aetheria product code.
|
|
- Split target blockers are now exported as `splitTargetBlockers[]` and as
|
|
per-target `blockerRecords[]` with blocker kind, subject, owner, and source
|
|
text. The split-target consumer smoke asserts Unity scene status/plugin
|
|
blockers, Electron feature blockers, and TUI command-transport blockers
|
|
without scraping the human `blockers[]` strings.
|
|
- EveUnity now has a pending Unity scene handoff at
|
|
`runtimes/incubating/eve-unity-scene/eveunity-scene-split-handoff.json`.
|
|
The active `unity-uitoolkit` runtime remains a semantic UI surface lowerer;
|
|
it is not treated as full scene/world projection. The pending `unity-scene`
|
|
runtime now names current scene graph and command-transport source paths,
|
|
while release, capture, non-Aetheria provider proof, and runtime graduation
|
|
remain EveUnity blockers.
|
|
- Unity scene now has a pending runtime capability manifest at
|
|
`runtimes/incubating/eve-unity-scene/eve-runtime-capability.json` and a
|
|
lifecycle smoke at `scripts/run-eveunity-scene-lifecycle-smoke.ps1`. The
|
|
manifest claims a provider-agnostic scene graph command surface for
|
|
`unity-scene`, types the package release, provider-advertisement scene smoke,
|
|
command boundary, and scene capture contracts. The release contract now uses
|
|
the Unity scene package manifest as version source and reuses the shared
|
|
EveUnity release request builder through
|
|
`scripts/run-eveunity-scene-release-contract-smoke.ps1`. It also reuses the
|
|
shared EveUnity capture request builder through
|
|
`scripts/run-eveunity-scene-capture-contract-smoke.ps1`, while the actual
|
|
Unity scene PNG/frame artifact remains pending. The scene graph now preserves
|
|
embedded document slot identity for resolver-backed child surfaces without
|
|
owning the nested plugin semantics. Sai, Norn, and TeX scene projection
|
|
adapters now exist as runtime-owned shells; TeX parsing, typesetting,
|
|
baseline metrics, and render-cache semantics remain plugin-owned.
|
|
- Unity scene now has a direct split handoff smoke at
|
|
`scripts/run-eveunity-scene-split-handoff-smoke.ps1`. The smoke verifies the
|
|
scene runtime's current source paths for runtime body, scene graph lowering,
|
|
Sai/Norn/TeX plugin projection, and command transport, does not treat
|
|
Aetheria product paths, Sai story state, Norn implementation state, or TeX
|
|
implementation state as generic runtime source, names the required Eve
|
|
contracts, and keeps capture as an external proof until EveUnity owns it.
|
|
- Runtime split handoff documents now have a catalog-backed schema,
|
|
`gamecult.eve.runtime_split_handoff.v1`. EveConformance exports that schema
|
|
so runtime owner repos can consume split target, move set, contract input,
|
|
forbidden import, and external proof shape without trusting only ad hoc smoke
|
|
script checks.
|
|
- Plugin, provider, and conformance handoff documents are now schema-backed as
|
|
`gamecult.eve.plugin_handoff.v1`, `gamecult.eve.provider_handoff.v1`, and
|
|
`gamecult.eve.conformance_handoff.v1`. The parity runner validates the
|
|
documents, exports the schema catalog entries, and owner-consumer smokes now
|
|
demand those contracts explicitly, so Sai, Norn, EvePlugins, Aetheria, and
|
|
EveConformance can consume handoff shape without depending on Eve's local
|
|
smoke script folklore.
|
|
- Runtime lifecycle shape is now schema-backed as
|
|
`gamecult.eve.runtime_lifecycle.v1`. Flutter's standalone
|
|
`eveflutter-lifecycle.json` validates against that contract, embedded
|
|
release/test/capture lifecycle blocks in runtime capability manifests are
|
|
wrapped and validated through the same schema, and the conformance export
|
|
carries `lifecycleManifestPath` plus `lifecycleErrors` so runtime owners can
|
|
consume lifecycle status without guessing from prose.
|
|
- Electron and TUI provider-shell outputs are now schema-backed as
|
|
`gamecult.eve.electron_shell_projection.v1` and
|
|
`gamecult.eve.tui_grid.v1`. Their runtime tests load the schema documents and
|
|
validate actual lowered projection objects, so Electron and TUI cannot claim
|
|
generic provider-shell lowering by string constant alone.
|
|
- EveElectron now has a pending split target and handoff at
|
|
`runtimes/incubating/eve-electron/eveelectron-split-handoff.json`. It does
|
|
claim a provider-agnostic Electron shell surface-tree projection and command
|
|
surface with Sai, Norn, and TeX sidecar plugin projection shells, but not
|
|
packaged rendering or captured window artifacts. The handoff draws the line
|
|
between the generic shell and Aetheria's Starbridge RTS product client, and
|
|
the split-target consumer smoke keeps release, packaged rendering, and
|
|
capture artifact proofs visible as blockers.
|
|
- EveElectron now has a direct split handoff smoke at
|
|
`scripts/run-eveelectron-split-handoff-smoke.ps1`. The smoke verifies the
|
|
current generic shell, command, and world-surface lowering paths, the observed
|
|
Aetheria Electron/client paths that must be replaced, the required Eve
|
|
contract inputs, and the pending external proofs without treating Aetheria's
|
|
product client as the generic Electron runtime.
|
|
- EveElectron now has a pending runtime capability manifest at
|
|
`runtimes/incubating/eve-electron/eve-runtime-capability.json` and a
|
|
lifecycle smoke at `scripts/run-eveelectron-lifecycle-smoke.ps1`. The
|
|
manifest declares provider advertisement consumption, command transport, and
|
|
surface-tree/plugin projection, claims `electron-shell` world/editor
|
|
lowering, and now carries executable release and capture request contracts.
|
|
Release uses
|
|
`tools/eveelectron/eveelectron-release-contract.mjs` and
|
|
`scripts/run-eveelectron-release-contract-smoke.ps1`; capture uses
|
|
`tools/eveelectron/eveelectron-capture-contract.mjs` and
|
|
`scripts/run-eveelectron-capture-contract-smoke.ps1`, plus a deterministic
|
|
`gamecult.eve.electron_shell_projection.v1` JSON projection artifact through
|
|
`tools/eveelectron/eveelectron-capture-artifact.mjs` and
|
|
`scripts/run-eveelectron-capture-smoke.ps1`. The packaged Electron app,
|
|
packaged window rendering, and actual Electron window PNG artifacts remain
|
|
pending EveElectron work.
|
|
- Electron pending lifecycle details and TUI active-incubation lifecycle details
|
|
now live in their runtime capability manifests rather than being duplicated in
|
|
`tools/parity/parity-manifest.json`. The parity ledger points at the
|
|
capability documents; the conformance export reads command/lifecycle contracts
|
|
from those documents for runtime targets.
|
|
- EveTui now has an active incubating runtime target and a split handoff at
|
|
`runtimes/incubating/eve-tui/evetui-split-handoff.json`. It claims the
|
|
advertised `tui` world-surface lowering target as a lossy terminal-grid
|
|
command surface and carries compact Sai, Norn, and TeX sidecar plugin
|
|
fallback shells. The handoff draws the line between the provider-agnostic
|
|
terminal/grid lowerer, plugin-owned semantics, and provider-owned TUI
|
|
surfaces, while the split-target consumer smoke keeps package release and
|
|
owner-repo capture production visible as blockers.
|
|
- EveTui now has a direct split handoff smoke at
|
|
`scripts/run-evetui-split-handoff-smoke.ps1`, an active runtime capability
|
|
manifest at `runtimes/incubating/eve-tui/eve-runtime-capability.json`, and a
|
|
lifecycle smoke at `scripts/run-evetui-lifecycle-smoke.ps1`. The manifest
|
|
declares provider advertisement consumption, command transport, terminal-grid
|
|
summary, terminal-grid lowering, sidecar plugin fallback projection, and the
|
|
`tui` world/editor lowering claim; it now carries an executable terminal
|
|
capture request contract through
|
|
`tools/evetui/evetui-capture-contract.mjs` and
|
|
`scripts/run-evetui-capture-contract-smoke.ps1`, plus a deterministic
|
|
`gamecult.eve.tui_grid.v1` JSON capture artifact through
|
|
`tools/evetui/evetui-capture-artifact.mjs` and
|
|
`scripts/run-evetui-capture-smoke.ps1`. Terminal package release and
|
|
owner-repo production of the capture path remain pending.
|
|
- EveTui release lifecycle now carries a structured pending release request
|
|
contract. The runtime capability manifest reads version truth from
|
|
`runtimes/incubating/eve-tui/package.json`, names the
|
|
`gamecult.eve.runtime_release_request.v1` request schema, and proves the
|
|
`evetui-v{version}` tag plus terminal runtime artifact path through
|
|
`tools/evetui/evetui-release-contract.mjs` and
|
|
`scripts/run-evetui-release-contract-smoke.ps1`. This proves the request
|
|
shape without pretending the EveTui package has been published.
|
|
- Aetheria interactive world surfaces now carry a structured provider-owned
|
|
`worldInteraction` contract. The provider advertisement names projection
|
|
kind, provider state schemas, daemon command boundary, receipt schema,
|
|
lowering targets, and ownership rules for `aetheria.daemon.game` and
|
|
`aetheria.daemon.editor`. The provider scenario requires the daemon game
|
|
world-surface contract, parity validates it against the advertisement, and the
|
|
conformance export carries both provider `surfaceContracts` and root
|
|
`interactiveWorldSurfaces[]` records. The Aetheria consumer smoke asserts the
|
|
advertised web, Unity UI Toolkit, and Unity scene lowering targets without
|
|
importing Aetheria or Eve internals.
|
|
- EveUnity test lifecycle now carries structured Unity EditMode runner
|
|
contracts. `packages/org.gamecult.eve.unity-uitoolkit/eve-runtime-capability.json`
|
|
and `runtimes/incubating/eve-unity-scene/eve-runtime-capability.json` name
|
|
runner scripts, the Aetheria consumer Unity project, package names, test
|
|
assemblies, platform, result artifacts, and temporary `testables` manifest
|
|
mutation. The shared runner restores Aetheria's `Packages/manifest.json`
|
|
after each run, while `scripts/run-aetheria-unity-scene-editmode-tests.ps1`
|
|
selects `org.gamecult.eve.unity-scene` and
|
|
`GameCult.Eve.UnityScene.Tests`. Lifecycle smokes validate the runner scripts
|
|
and Aetheria project, parity compares the contracts against the ledger, and
|
|
runtime-owner consumer smoke asserts exported test fields. UI Toolkit still
|
|
carries the CultLib-managed precompiled assembly dependency proof; Unity
|
|
Scene now carries a generic playable-world EditMode proof through the real
|
|
Aetheria consumer project.
|
|
- EveUnity release lifecycle now carries a structured UPM release contract.
|
|
`packages/org.gamecult.eve.unity-uitoolkit/eve-runtime-capability.json`
|
|
names the package root, version source, tag pattern, artifact kind, and
|
|
owner-side publish proof for `org.gamecult.eve.unity-uitoolkit`.
|
|
`tools/eveunity/eveunity-release-contract.mjs` now builds a
|
|
`gamecult.eve.runtime_release_request.v1` request from the runtime capability
|
|
manifest and UPM package manifest, deriving the `eveunity-uitoolkit-v{version}`
|
|
tag, package dependency set, required package dependency owners, and UPM
|
|
artifact path. `tools/eveunity/eveunity-release-artifact.mjs` consumes that
|
|
request and runs `npm pack` against the declared package root, producing the
|
|
declared UPM `.tgz` artifact as local smoke evidence. The lifecycle smoke
|
|
validates that contract against the package manifest, parity compares it
|
|
against the ledger, and the runtime-owner consumer smoke asserts the exported
|
|
release fields without pretending the tagged EveUnity release already exists.
|
|
- EveUnity capture lifecycle now carries a structured pending capture contract.
|
|
`captureContract` names the Unity UI Toolkit runtime, capture kind, PNG
|
|
artifact pattern, conformance attachment point, required Aetheria provider
|
|
surface, request schema, request builder, advertisement input, and authority
|
|
rule. `tools/eveunity/eveunity-capture-contract.mjs` now builds a
|
|
`gamecult.eve.runtime_capture_request.v1` request from the runtime capability
|
|
manifest and provider advertisement, and
|
|
`scripts/run-eveunity-capture-contract-smoke.ps1` proves that request path
|
|
without pretending a Unity PNG has been captured. The actual capture artifact
|
|
remains a split blocker for EveUnity.
|
|
- Unity UI Toolkit now also has schema-backed semantic projection evidence.
|
|
`tools/eveunity/eveunity-uitoolkit-capture-artifact.mjs` lowers
|
|
`web/fixtures/aetheria-world-surface.json` into
|
|
`gamecult.eve.unity_uitoolkit_projection.v1`, writes
|
|
`artifacts/eveunity-uitoolkit-capture/latest/unity-uitoolkit-projection.json`,
|
|
and exports it as `runtime.captureArtifacts[]`. The builder also proves Sai,
|
|
Norn, and TeX stay sidecar plugin projections when a visual-novel surface is
|
|
lowered through UI Toolkit. The remaining EveUnity capture blocker is an
|
|
owner-repo Unity editor or batchmode PNG, not absence of a typed projection
|
|
artifact.
|
|
- Unity scene capture now has the same semantic artifact boundary as Electron
|
|
without pretending it is a rendered Unity frame. `tools/eveunity/eveunity-scene-capture-artifact.mjs`
|
|
lowers `web/fixtures/aetheria-world-surface.json` into
|
|
`gamecult.eve.unity_scene_projection.v1`, writes
|
|
`artifacts/eveunity-scene-capture/latest/unity-scene-projection.json`, and
|
|
exports it as `runtime.captureArtifacts[]`. The builder also proves Sai,
|
|
Norn, and TeX remain sidecar plugin projections when a visual-novel surface
|
|
is lowered. The remaining EveUnity blocker is an owner-repo Unity screenshot
|
|
or frame-capture PNG, not absence of semantic scene projection evidence.
|
|
- Unity scene lowering now extracts a provider-authored playable ARPG world
|
|
model from the Aetheria daemon game surface without importing Aetheria runtime
|
|
types. The Aetheria fixture carries generic `world.scene3d`,
|
|
`world.entity3d`, asset-manifest, input-profile, camera, movement, focus, and
|
|
target command affordances; `EveUnitySceneSurfaceLowerer` exposes them as a
|
|
`PlayableWorld` projection, and the JSON capture artifact exports the same
|
|
`playableWorld` shape under `gamecult.eve.unity_scene_projection.v1`.
|
|
`EveUnitySceneClientSession` now consumes provider surface snapshots and emits
|
|
movement/focus/target/action intents through the advertised command boundary,
|
|
while `EveUnitySceneProviderConnection` defines the generic surface source
|
|
and command sink ports that a CultMesh/CultNet adapter must implement.
|
|
`IEveUnitySceneProviderSurfaceDocumentSource`,
|
|
`EveUnitySceneProviderSurfaceDocument`, and
|
|
`EveUnitySceneProviderSurfaceDocumentSource` now add the typed provider
|
|
document boundary in front of those snapshots, so live CultMesh/CultCache
|
|
readers can publish daemon-owned surface documents without teaching EveUnity
|
|
Aetheria types.
|
|
`EveUnityPlayableWorldLiveClient` now composes the provider connection with
|
|
the playable-world presenter, so provider snapshots immediately drive scene
|
|
presentation and Unity input still exits through the provider command sink
|
|
rather than local simulation. The same live client now observes provider
|
|
command receipts through `IEveUnitySceneCommandReceiptSource`: pending
|
|
receipts remain status only, while accepted or reconciled receipts refresh
|
|
from the provider surface source instead of moving entities locally.
|
|
`EveUnityPlayableWorldRuntime` now owns the generic Unity playable-world
|
|
composition point: provider surface documents, provider asset manifest
|
|
documents, command sink, optional receipt source, asset manifest cache,
|
|
presenter, and scene sink are wired without Aetheria imports.
|
|
`EveUnityPlayableWorldPresenter` now maps provider-authored entity rows and
|
|
asset refs into scene sink operations, including removal of entities absent
|
|
from later provider snapshots, without importing Aetheria entity/prefab
|
|
classes. `EveUnityGameObjectPlayableWorldSceneSink` now provides the first
|
|
Unity-native sink body: generic `GameObject` creation/update/removal,
|
|
transform/radius application, entity markers, and a swappable asset-provider
|
|
hook. `EveUnityPlayableWorldAssetManifest` and
|
|
`EveUnityManifestGameObjectAssetProvider` map provider-authored asset refs and
|
|
entity kinds to Unity resource/prefab keys through data, not Aetheria code.
|
|
`IEveUnityPlayableWorldAssetManifestSource` and
|
|
`EveUnityPlayableWorldAssetManifestCache` key live manifest updates by the
|
|
`playableWorld.AssetManifest` pointer, so the future CultMesh/CultCache
|
|
reader can update Unity asset bindings without changing scene lowering.
|
|
`gamecult.eve.unity_playable_world_asset_manifest.v1` and
|
|
`EveUnityPlayableWorldAssetManifestDocumentSource` now define the typed
|
|
manifest document loading boundary and feed that cache without importing
|
|
Aetheria asset classes. `EveUnityLivePlayableWorldAssetProvider` connects
|
|
that cache to the active world pointer for GameObject scenes. The Unity
|
|
client boundary is generic before it learns live transport.
|
|
`EveUnityPlayableWorldClientHost`,
|
|
`EveUnityPlayableWorldClientBootstrap`,
|
|
`EveUnityPlayableWorldInputDriver`, and `EveUnityPlayableWorldCameraRig` now
|
|
form the first generic Unity client body: a provider component that implements
|
|
the Eve interfaces can be mounted without Aetheria-specific client code,
|
|
provider-authored entities are instantiated under a Unity scene root, camera
|
|
and movement input are runtime-owned, and movement exits through the
|
|
provider-advertised `gamecult.eve.command.v1` boundary.
|
|
`EveUnitySceneLiveProviderBridge` now names the runtime-owned live transport
|
|
port: a CultMesh/CultNet transport supplies provider surface documents, asset
|
|
manifest documents, command submission, receipts, and refresh requests through
|
|
`IEveUnitySceneLiveProviderTransport`, while the bridge exposes the existing
|
|
scene runtime source/sink/receipt interfaces without importing provider
|
|
internals. The Unity scene EditMode proof now includes
|
|
`LiveProviderBridgeFeedsPlayableWorldRuntimeThroughTransportPorts`, proving
|
|
the generic playable-world runtime can consume that transport-shaped boundary.
|
|
Aetheria now provides the owner-repo proof by exposing
|
|
`AetheriaEveUnitySceneProviderBridge` as an
|
|
`IEveUnitySceneLiveProviderTransport`; the generic Eve live bridge consumes
|
|
that transport and drives `EveUnityPlayableWorldRuntime` without the runtime
|
|
importing Aetheria scene classes. Aetheria's provider advertisement and
|
|
surface catalog now publish the world interaction metadata the Unity scene
|
|
document needs: surface kind, projection kind, command boundary, receipt
|
|
schema, ownership, lowering targets, state schemas, and record pointer. The
|
|
Aetheria Unity bridge now selects that provider-owned advertisement instead of
|
|
fabricating the Unity scene metadata locally. The asset manifest leg is now a
|
|
first-class live transport proof rather than a local catalog projection:
|
|
Aetheria client state exposes `AssetManifest`, the provider bridge reads
|
|
`runtimeState.AssetManifest.Latest()`, and the Unity manifest document points
|
|
at `AetheriaRuntimeVerseRecordKeys.DaemonAssetManifest`. EveUnity still
|
|
consumes only the generic provider/plugin contracts and sidecar transport
|
|
ports; Aetheria keeps the gameplay and asset authority. The remaining blocker
|
|
has narrowed again: Aetheria now mounts
|
|
`AetheriaEveUnitySceneProviderComponent` through the generic
|
|
`EveUnityPlayableWorldClientHost`, instantiates provider-authored daemon
|
|
entities under a real Unity `GameObject` scene root, and drives the generic
|
|
camera rig from the advertised player entity without Aetheria-specific Unity
|
|
client code. The remaining blocker is owner-repo PNG/frame capture from the
|
|
future EveUnity repo, with provider receipts plus daemon snapshots driving
|
|
frames rather than renderer-local simulation.
|
|
- EveElectron capture lifecycle now carries the same kind of structured pending
|
|
capture contract. `captureContract` names the Electron shell runtime, capture
|
|
kind, PNG artifact pattern, conformance attachment point, required Aetheria
|
|
provider surface, request schema, request builder, advertisement input, and
|
|
authority rule. `tools/eveelectron/eveelectron-capture-contract.mjs` builds a
|
|
`gamecult.eve.runtime_capture_request.v1` request from the runtime capability
|
|
manifest and provider advertisement, and
|
|
`scripts/run-eveelectron-capture-contract-smoke.ps1` proves that request path.
|
|
`tools/eveelectron/eveelectron-capture-artifact.mjs` now also lowers the
|
|
Aetheria world surface through `EveElectronShell`, writes
|
|
`artifacts/eveelectron-capture/latest/electron-shell-projection.json`, and
|
|
exports it as `runtime.captureArtifacts[]`. The actual packaged window PNG
|
|
remains a split blocker for EveElectron.
|
|
- Runtime capture probe coverage is now exported as
|
|
`runtimeCaptureProbeCoverage[]`. It records the lifecycle capture contract,
|
|
capture owner, requested artifact kind, current semantic/cell-grid artifact,
|
|
request path, pending proofs, and validation errors for each runtime with
|
|
capture evidence. The consumer smokes assert that Unity UI Toolkit, Unity
|
|
scene, and Electron currently have `json-projection` semantic artifacts while
|
|
their contracted `png` captures remain owner-repo work; TUI's current
|
|
`json-grid` artifact satisfies its contract but still needs EveTui ownership.
|
|
- EveTui capture lifecycle now attaches a typed terminal-grid artifact instead
|
|
of stopping at a request contract. `tools/evetui/evetui-capture-artifact.mjs`
|
|
lowers `web/fixtures/aetheria-world-surface.json` through `EveTuiShell`,
|
|
writes `artifacts/evetui-capture/latest/tui-grid.json`, and stores the paired
|
|
capture request beside it. Parity validates the artifact schema, provider,
|
|
surface, and linked request path, then exports it as `runtime.captureArtifacts[]`.
|
|
The split blocker is no longer "no artifact"; it is "EveTui must own this
|
|
capture path outside Eve incubation."
|
|
- EveElectron release lifecycle now carries a structured pending release
|
|
request contract. `releaseContract` names
|
|
`gamecult.eve.runtime_release_request.v1`, the
|
|
`tools/eveelectron/eveelectron-release-contract.mjs` request builder,
|
|
`runtimes/incubating/eve-electron/package.json` as the version source, and
|
|
the `eveelectron-v{version}` tag/artifact pattern.
|
|
`scripts/run-eveelectron-release-contract-smoke.ps1` proves the request
|
|
without pretending a packaged Electron app has been published.
|
|
- Unity scene capture now uses that same request-contract shape. The
|
|
`unity-scene` runtime capability manifest names
|
|
`gamecult.eve.runtime_capture_request.v1`, the shared
|
|
`tools/eveunity/eveunity-capture-contract.mjs` request builder, the Aetheria
|
|
provider advertisement input, and the scene PNG artifact pattern.
|
|
`scripts/run-eveunity-scene-capture-contract-smoke.ps1` proves the request
|
|
without pretending a Unity scene frame has been captured. The actual frame or
|
|
screenshot artifact remains a split blocker for EveUnity.
|
|
- Unity scene release now uses the same UPM release request contract shape as
|
|
Unity UI Toolkit. The `unity-scene` runtime capability manifest names
|
|
`gamecult.eve.runtime_release_request.v1`, the shared
|
|
`tools/eveunity/eveunity-release-contract.mjs` request builder,
|
|
`tools/eveunity/eveunity-release-artifact.mjs` artifact builder,
|
|
`runtimes/incubating/eve-unity-scene/package.json` as the version source, and
|
|
the `eveunity-scene-v{version}` tag/artifact pattern.
|
|
`scripts/run-eveunity-scene-release-artifact-smoke.ps1` now produces the
|
|
declared Unity scene UPM `.tgz` as local smoke evidence without pretending the
|
|
tagged UPM package has been published from EveUnity.
|
|
- EveTui capture lifecycle now carries a structured terminal cell-grid capture
|
|
contract and typed artifact. `captureContract` names the TUI runtime,
|
|
`terminal-cell-grid` capture kind, `json-grid` artifact kind, conformance
|
|
attachment point, required Aetheria provider surface, request schema, request
|
|
builder, advertisement input, and authority rule.
|
|
`tools/evetui/evetui-capture-contract.mjs` builds a
|
|
`gamecult.eve.runtime_capture_request.v1` request from the runtime capability
|
|
manifest and provider advertisement, and
|
|
`tools/evetui/evetui-capture-artifact.mjs` writes
|
|
`gamecult.eve.tui_grid.v1` evidence. The remaining blocker is owner-repo
|
|
production of the same capture path, not absence of a cell-grid artifact.
|
|
- Runtime-owner conformance consumption now asserts EveUnity lifecycle stage
|
|
evidence directly. The generic consumer supports
|
|
`--expect-runtime-lifecycle-status` and
|
|
`--expect-runtime-lifecycle-pending`; the runtime-owner smoke verifies the
|
|
Unity UI Toolkit release/test/capture statuses plus the tagged UPM release,
|
|
batchmode runner, and capture artifact pending proofs from the exported
|
|
runtime record.
|
|
- Plugin manifests and advertisements now carry a typed runtime-independent
|
|
sidecar ABI boundary. Sai, Norn, and TeX declare `invocationModel:
|
|
executable-sidecar`, `gamecult.eve.plugin_abi.v1`, CultMesh/stdio transports,
|
|
renderer independence, no provider-state mutation, provider-owned command
|
|
acceptance, and `runtime.sidecar` fields for process kind, protocol,
|
|
request/response schemas, operations, command envelope, receipt schema, and
|
|
state authority. The parity harness validates manifest/advertisement
|
|
agreement, checks sidecar operations against ABI fixture operations, exports
|
|
the runtime boundary, and the plugin-owner consumer smoke asserts the Sai and
|
|
Norn sidecar contracts from the conformance pack.
|
|
- The plugin-owner conformance consumer now asserts independent nested plugin
|
|
composition directly. `--expect-independent-nested-plugin` verifies that the
|
|
Sai VN provider surface requires `sai.vn` while `norn.graph` and `tex.math`
|
|
remain `optional-nested`, separately owned, sidecar-provided capabilities.
|
|
That keeps a Sai surface free to deploy with Norn or TeX when available
|
|
without turning either plugin into a Sai dependency or runtime-hosted
|
|
semantic authority.
|
|
- The split-target conformance consumer now asserts EveUnity's generic
|
|
interactive-world capture controls. `unity-uitoolkit` and `unity-scene` must
|
|
export `runtime.captureArtifacts[]` for both Aetheria and the non-product
|
|
`eve.world-smoke` provider, proving the Unity lowerers are generic runtime
|
|
clients before the remaining blocker narrows to owner-repo PNG/frame capture
|
|
and release lifecycle.
|
|
- The same split-target consumer now asserts EveElectron's generic
|
|
interactive-world shell controls. `electron-shell` must export
|
|
`runtime.captureArtifacts[]` for both Aetheria and `eve.world-smoke`, so the
|
|
Aetheria RTS web client remains provider pressure while the generic Electron
|
|
shell proof stays runtime-owned.
|
|
- EveTui split-target consumption now follows the same rule. `tui` must export
|
|
`runtime.captureArtifacts[]` for both Aetheria and `eve.world-smoke`, proving
|
|
the compact terminal-grid lowerer is a provider-agnostic runtime client while
|
|
package release and owner-repo capture production remain explicit blockers.
|
|
- The Aetheria provider consumer now asserts the runtime artifacts it relies on:
|
|
Unity UI Toolkit, Unity Scene, Electron shell, and TUI must all export
|
|
Aetheria `runtime.captureArtifacts[]` for `aetheria.daemon.game`. That makes
|
|
the provider-side proof consume generic lowering clients instead of stopping
|
|
at advertised target coverage.
|
|
- Runtime capture requests now select a declared provider surface, not only a
|
|
provider id. Unity UI Toolkit, Electron shell, and TUI declare
|
|
`aetheria.daemon.editor` as an additional capture surface, while Unity Scene
|
|
rejects the editor surface because Aetheria does not advertise `unity-scene`
|
|
for editor lowering. This keeps game/editor capture authority explicit.
|
|
- Conformance export now carries first-class `capabilityGaps[]` records derived
|
|
from plugin errors, provider advertisement/scenario errors, runtime missing
|
|
evidence, declared unsupported plugin projection, capture gaps, and split
|
|
blockers. The generic consumer can assert named gaps with
|
|
`--expect-capability-gap`; the default smoke now proves Direct2D capture and
|
|
EveUnity release ownership remain visible blockers instead of hiding in
|
|
Markdown prose.
|
|
- Conformance export now carries a first-class
|
|
`gamecult.eve.capability_matrix.v1` projection. The matrix summarizes pack
|
|
health, plugin ABI/capability claims, provider surfaces/commands/receipts,
|
|
runtime feature/capture/command coverage, split readiness, and handoff counts
|
|
from the exported evidence. The generic consumer smoke asserts it with
|
|
`--expect-capability-matrix`, so owner repos do not need to scrape the
|
|
Markdown report or rebuild Eve's summary logic to understand coverage.
|
|
- The capability matrix projection now has a catalog-backed schema document at
|
|
`schemas/gamecult.eve.capability_matrix.v1.schema.json`, and the generic
|
|
conformance consumer asserts that schema from the exported pack.
|
|
- Conformance export now copies handoff documents into `handoffs/*.json` rather
|
|
than exporting Eve-local source paths only. The export carries handoff export
|
|
paths for EveConformance, Sai/Norn plugins, Aetheria, and EveUnity; the
|
|
generic consumer verifies those copied documents for conformance, plugin,
|
|
provider, and runtime handoff assertions. Owner repos can inspect the
|
|
boundary map from the exported pack itself.
|
|
- EveConformance now has a machine-readable handoff at
|
|
`tools/conformance/eveconformance-handoff.json` and a verifier at
|
|
`scripts/run-eveconformance-handoff-smoke.ps1`. The handoff names the
|
|
conformance runner, schemas, consumer smokes, fixture corpus, contract inputs,
|
|
forbidden imports, and external proofs that leave Eve when the harness
|
|
graduates. The conformance export carries `conformanceHandoffPath`, and the
|
|
generic consumer smoke asserts it so EveConformance split readiness is not
|
|
trapped in Eve's parity manifest.
|
|
- Sai, Norn, and TeX now have plugin handoff manifests at
|
|
`plugins/incubating/sai-vn.plugin-handoff.json`,
|
|
`plugins/incubating/norn-graph.plugin-handoff.json`, and
|
|
`plugins/incubating/tex-math.plugin-handoff.json`, plus a shared verifier at
|
|
`scripts/run-plugin-handoff-smoke.ps1`. The handoffs name the manifest,
|
|
advertisement, ABI fixture, move sets, contract inputs, forbidden imports,
|
|
and external proofs that must move to the owner repos. The conformance export
|
|
carries plugin `handoffPath` and `pluginHandoffMoveCoverage[]`, and the
|
|
plugin-owner smoke asserts them so Sai, Norn, and EvePlugins can consume the
|
|
plugin boundary without reading Eve's parity manifest.
|
|
- Aetheria now has a provider handoff manifest at
|
|
`web/fixtures/aetheria-provider-handoff.json` and a verifier at
|
|
`scripts/run-aetheria-provider-handoff-smoke.ps1`. The handoff names the
|
|
advertisement, interactive world fixture, provider scenario, contract inputs,
|
|
forbidden imports, and external proofs that must move to Aetheria. The
|
|
conformance export carries the handoff path and
|
|
`providerHandoffMoveCoverage[]`, and the Aetheria consumer smoke asserts
|
|
provider advertisement, interactive world surface, conformance fixture, and
|
|
scenario move records so provider ownership does not depend on Eve's source
|
|
layout or parity manifest.
|
|
- EveUnity now has a machine-readable split handoff at
|
|
`packages/org.gamecult.eve.unity-uitoolkit/eveunity-split-handoff.json` and
|
|
a verifier at `scripts/run-eveunity-split-handoff-smoke.ps1`. The handoff
|
|
names the UPM package body, Unity test lifecycle, Unity capture lifecycle,
|
|
contract inputs, forbidden imports, and required external proofs that must
|
|
move to EveUnity. It is wired into the runtime capability manifest and
|
|
lifecycle smoke, so the remaining split blockers are release/test/capture
|
|
ownership rather than an undocumented migration shape.
|
|
- Split-target conformance consumption now verifies graduation state instead of
|
|
only split-target presence. The generic consumer supports
|
|
`--expect-split-target-status`, `--expect-split-target-blocker`, and
|
|
`--expect-split-target-proof`; the parity harness runs
|
|
`scripts/run-split-target-conformance-consumer-smoke.ps1`; and EveFlutter /
|
|
EveUnity consumers can now prove that the targets remain incubating for named
|
|
blockers while their current split-readiness proofs stay passed.
|
|
- Runtime owner conformance consumption now verifies runtime target health
|
|
instead of only runtime presence. The generic consumer supports
|
|
`--expect-runtime-status`, `--expect-runtime-feature`,
|
|
`--expect-runtime-command-schema`, and `--expect-runtime-capture-status`; the
|
|
export carries top-level `captureStatus`; and the parity harness runs a
|
|
runtime-owner smoke that proves active Flutter/Unity/web targets while keeping
|
|
Fensalir Direct2D explicitly demoted as `external-adapter-spike` with missing
|
|
capture.
|
|
- Provider owner conformance consumption now verifies the interactive-world
|
|
contract instead of only provider presence. The generic conformance consumer
|
|
supports `--expect-provider-surface`, `--expect-provider-surface-kind`,
|
|
`--expect-provider-command`, and `--expect-provider-receipt-state`; the
|
|
export now carries provider receipt states and surface-kind claims; and
|
|
Aetheria's consumer smoke asserts the daemon game/editor surfaces,
|
|
interactive world surface roles, daemon command boundary, and
|
|
accepted/reconciled receipts from the exported provider pack.
|
|
- Plugin owner conformance consumption now has a smoke runner at
|
|
`scripts/run-plugin-owner-conformance-consumer-smoke.ps1`. The generic
|
|
conformance consumer can assert plugin ABI operations and capabilities with
|
|
`--expect-plugin-operation` and `--expect-plugin-capability`, and the export
|
|
now carries plugin manifest paths, advertisement paths, split targets,
|
|
graduation triggers, and optional nested composition claims. Sai and Norn can
|
|
prove the plugin contract from the conformance export without reading Eve's
|
|
parity manifest.
|
|
- EveUnity now has a split lifecycle smoke at
|
|
`scripts/run-eveunity-lifecycle-smoke.ps1`. It validates the existing
|
|
`packages/org.gamecult.eve.unity-uitoolkit/eve-runtime-capability.json`
|
|
lifecycle claims directly instead of duplicating them, checks evidence paths,
|
|
and runs the Aetheria Unity package consumer-build smoke. `-RunUnityEditMode`
|
|
is available for the heavier Unity batchmode path. EveUnity remains
|
|
incubating until tagged UPM release, batchmode runner ownership, and capture
|
|
artifacts live under the `EveUnity` repo.
|
|
- EveFlutter now has explicit lifecycle incubation evidence at
|
|
`flutter/eve_parity/eveflutter-lifecycle.json` and a smoke runner at
|
|
`scripts/run-eveflutter-lifecycle-smoke.ps1`. The smoke validates the
|
|
lifecycle document, checks release/test/capture evidence paths, runs Dart
|
|
analysis from the bundled SDK, and consumes the exported conformance pack from
|
|
inside `flutter/eve_parity`. The split-readiness blocker is now narrower:
|
|
tagged release, test runner ownership, and capture runner ownership must move
|
|
to `EveFlutter`, rather than pretending the lifecycle shape is still unknown.
|
|
- EveFlutter now has a provider-catalog picker primitive. `EveProviderCatalog`
|
|
parses conformance-export provider entries, including separate Sai, Norn, and
|
|
TeX plugin requirements, and `EveProviderPicker` selects those provider ids without
|
|
reading web fixture paths. The Flutter smoke test proves provider selection
|
|
from an export-shaped provider list, so the split-readiness report records the
|
|
provider-picker proof as passed while leaving release/capture lifecycle
|
|
ownership as the remaining EveFlutter blocker.
|
|
- EveFlutter now has a conformance consumer smoke at
|
|
`scripts/run-eveflutter-conformance-consumer-smoke.ps1`. It runs from
|
|
`flutter/eve_parity`, consumes the exported conformance pack, and asserts the
|
|
runtime pack, Sai provider fixture, Flutter runtimes, and `EveFlutter` split
|
|
target without reading Eve's parity manifest. The split-readiness report now
|
|
records that as a passed proof instead of leaving it as a permanent pending
|
|
blocker.
|
|
- Fensalir now has a recorded runtime-pack
|
|
`gamecult.eve.surface.v1` adapter fixture at
|
|
`web/fixtures/fensalir-direct2d-surface.json`. The browser local catalog uses
|
|
that contract-shaped surface instead of the older dashboard-state sketch, and
|
|
the parity harness validates embedded-slot preservation, command descriptors,
|
|
runtime authority witnesses, and style tokens. Direct2D capture and
|
|
runtime-owned command smoke remain the activation blockers.
|
|
- UIKit and Kotlin device-edge runtimes no longer consume the Sai plugin fixture
|
|
as projection acceptance targets. They remain generic embedded-document and
|
|
device-edge proofs; plugin projection authority belongs to EveFlutter,
|
|
EveUnity, EveElectron, EveTui, or future runtime-specific adapters when those
|
|
bodies earn the claim.
|
|
- Android Kotlin now maps surface style tokens into its lightweight parity
|
|
fixture typography path. `MainActivity.kt` uses token-aware text roles,
|
|
parses future text-size/scale tokens, and maps `fontBody`, `fontTitle`, and
|
|
`fontMono` to Android typefaces while keeping Kotlin device-edge scope limited
|
|
to generic embedded documents, style tokens, and sensor/uplink work. It still
|
|
does not claim Sai/Norn/TeX plugin projection acceptance.
|
|
- The web reference no longer hardcodes the local provider list in
|
|
`web/surface.js`. It loads `web/local-provider-catalog.json`, then opens
|
|
advertisement-backed entries for Aetheria, Repixelizer, and Sai through the
|
|
same `loadProviderAdvertisement` path used by the provider picker. Fixture-only
|
|
surfaces remain explicit local catalog entries until they gain provider
|
|
advertisements or move into their owner packs. The fallback catalog is now
|
|
schema-backed as `gamecult.eve.local_provider_catalog.v1`, copied into the
|
|
conformance export, and indexed as `localProviderCatalogs[]` so external
|
|
consumers can verify which provider advertisements the browser reference uses
|
|
without importing Eve's source layout.
|
|
- Provider advertisements can now name sidecar plugin requirements per surface
|
|
with `surfaces[].requiresPlugins[]`. The parity harness validates those
|
|
requirements against known plugin manifests, exports them in the conformance
|
|
provider list, and reports missing plugins or capabilities as provider
|
|
capability gaps. The Sai VN fixture now has an advertisement-shaped provider
|
|
entry for `gamecult.home.vn`, so Sai, Norn, and TeX requirements sit at
|
|
separate provider/plugin boundaries instead of hiding only in fixture
|
|
metadata.
|
|
- The conformance runtime pack now exports `runtimeTargets` in
|
|
`artifacts/conformance/latest/packs/runtime.json`. Runtime repos can consume
|
|
runtime status, feature/plugin claims, command schema, lifecycle, capture
|
|
status, capability manifest path, and missing evidence without depending on
|
|
Eve's parity manifest layout.
|
|
- Sai, Norn, and TeX plugin ABI fixtures now cover `lower` and `measure` in
|
|
addition to `describe`, `validate`, `project`, and `apply`. Eve validates the
|
|
operation shape, preserved component kinds, measurement outputs, and provider
|
|
authority flag without importing plugin internals or deciding plugin
|
|
semantics.
|
|
- The web reference now publishes a runtime capability manifest at
|
|
`web/eve-runtime-capability.json`, and the parity harness validates it through
|
|
the same runtime capability path as Unity. Web remains Eve's behavior oracle,
|
|
not an EveWeb split target, unless it gains independent deployment lifecycle.
|
|
Its manifest explicitly claims provider advertisement consumption,
|
|
embedded-document lowering, state bindings, style tokens, authority witnesses,
|
|
plugin projection support, command intent emission, and Chrome headless
|
|
capture evidence.
|
|
- Unity UI Toolkit now declares runtime lifecycle evidence in
|
|
`packages/org.gamecult.eve.unity-uitoolkit/eve-runtime-capability.json`. The
|
|
parity harness validates release, test, and capture lifecycle claims against
|
|
`tools/parity/parity-manifest.json`, checks declared evidence paths, and
|
|
exports lifecycle status through the conformance index. Current proof covers
|
|
incubating UPM package identity, package EditMode tests, Aetheria
|
|
consumer-build smoke, and an Eve-owned batchmode EditMode run through the
|
|
Aetheria Unity project; tagged EveUnity release, moving the batchmode runner
|
|
into EveUnity, and editor or batchmode capture remain explicit split
|
|
blockers.
|
|
- Aetheria now has repeatable Unity EditMode evidence for the Eve UI Toolkit
|
|
runtime. `scripts/run-aetheria-unity-editmode-tests.ps1` temporarily adds
|
|
`org.gamecult.eve.unity-uitoolkit` to Aetheria's Unity `testables`, runs
|
|
`GameCult.Eve.UnityUIToolkit.Tests` in Unity batchmode, writes XML and log
|
|
artifacts under `artifacts/aetheria-unity-editmode`, and restores
|
|
`Packages/manifest.json` before returning. The Brokkr/CultMesh DLL references
|
|
in the Unity test asmdef are now mirrored by
|
|
`testContract.managedAssemblyDependencies`, with CultLib named as the
|
|
NuGet/package owner. EveUnity's split blocker is proving how the Unity package
|
|
resolves those assemblies after it leaves Eve incubation, not inventing a
|
|
dependency system for CultLib. This proves the incubating test lifecycle; it
|
|
does not make Eve own Unity's final runtime lifecycle.
|
|
- Aetheria now has the same repeatable Unity EditMode evidence for the
|
|
EveUnity scene runtime. `scripts/run-aetheria-unity-scene-editmode-tests.ps1`
|
|
temporarily adds `org.gamecult.eve.unity-scene` to Aetheria's Unity
|
|
`testables`, runs `GameCult.Eve.UnityScene.Tests`, writes XML and log
|
|
artifacts under `artifacts/aetheria-unity-scene-editmode`, and restores
|
|
`Packages/manifest.json`. This proves the generic playable-world host,
|
|
bootstrap, input, camera, scene sink, and command-envelope tests compile and
|
|
run through the Aetheria consumer project without making the Unity client
|
|
Aetheria-specific.
|
|
- Aetheria now also carries the real provider-side proof for the target shape:
|
|
a generic `EveUnityPlayableWorldRuntime` lowers the daemon-published 3D ARPG
|
|
world surface through the Aetheria Eve provider bridge, resolves
|
|
provider-owned playable-world asset refs through the daemon-published
|
|
`AetheriaRuntimeVerseRecordKeys.DaemonAssetManifest` record, submits movement
|
|
through the advertised `gamecult.eve.command.v1` boundary, observes
|
|
provider-owned receipts, and refreshes from daemon snapshots without
|
|
importing Aetheria product authority into EveUnity. The generic Unity
|
|
document-source wrapper now connects live provider sources through
|
|
`IEveUnitySceneProviderSurfaceDocumentConnection`, delegates provider refresh
|
|
through `IEveUnityProviderRefreshSource`, `Connect()` is idempotent for the
|
|
current snapshot, and `EveUnitySceneLiveProviderBridge` forwards receipts
|
|
while `EveUnityPlayableWorldLiveClient` owns refresh-on-terminal receipt
|
|
policy. Aetheria also proves the
|
|
generic Unity scene body, not only a recording sink:
|
|
`GenericEveUnityClientHostInstantiatesAetheriaDaemonWorldThroughProviderComponent`
|
|
mounts the public provider component through `EveUnityPlayableWorldClientHost`,
|
|
creates provider-authored `EveUnityPlayableWorldEntityMarker` GameObjects, and
|
|
applies `EveUnityPlayableWorldCameraRig` against the advertised player.
|
|
Eve records this as the `aetheria-playable-world-consumer-proof`
|
|
observed-provider move set in
|
|
`runtimes/incubating/eve-unity-scene/eveunity-scene-split-handoff.json`, and
|
|
the split-target plus Aetheria consumer smokes assert it from the conformance
|
|
export. The remaining blocker is owner-repo PNG/frame capture from the future
|
|
EveUnity repo, not whether the Unity client is generic.
|
|
- Aetheria now has repeatable Unity package consumer-build evidence for the
|
|
Eve UI Toolkit runtime. `scripts/run-aetheria-unity-package-smoke.ps1`
|
|
verifies Aetheria's Unity `Packages/manifest.json` consumes Eve's surface,
|
|
Unity scene, and UI Toolkit packages by file reference, checks the generated
|
|
Unity projects include all current runtime files, asserts the Aetheria Unity
|
|
bridge reads `runtimeState.AssetManifest.Latest()` from client state
|
|
`AssetManifest` and publishes the
|
|
`AetheriaRuntimeVerseRecordKeys.DaemonAssetManifest` pointer, then builds the
|
|
packages through Aetheria's Unity-generated projects.
|
|
- The EveUnity UI Toolkit split handoff now records Aetheria's Unity consumer
|
|
boundary as `observed-provider` evidence. The handoff names Aetheria's
|
|
package manifest, generated Unity project, assets root, daemon catalog
|
|
client, and Unity smoke as provider-owned pressure sources that prove a real
|
|
game consumes EveUnity without making those Aetheria paths EveUnity source.
|
|
`scripts/run-eveunity-split-handoff-smoke.ps1`,
|
|
`scripts/run-split-target-conformance-consumer-smoke.ps1`, and
|
|
`scripts/run-aetheria-conformance-consumer-smoke.ps1` assert that boundary
|
|
from the manifest/export.
|
|
- Unity UI Toolkit now attaches a schema-backed semantic projection capture
|
|
artifact at
|
|
`artifacts/eveunity-uitoolkit-capture/latest/unity-uitoolkit-projection.json`.
|
|
Parity validates it against
|
|
`gamecult.eve.unity_uitoolkit_projection.v1`, exports it as
|
|
`runtime.captureArtifacts[]`, and the runtime-owner consumer smoke asserts it.
|
|
This proves the UI Toolkit command-surface projection is typed evidence while
|
|
leaving real Unity editor or batchmode PNG capture as the EveUnity blocker.
|
|
- Unity UI Toolkit now has a first-party `norn.graph` projection-adapter proof
|
|
for `embed.norn`. `NornGraphUiToolkitProjectionAdapter` owns the native
|
|
embedded graph shell and graph command emission path, while the Norn sidecar
|
|
plugin keeps graph layout and graph semantics. UI Toolkit split-readiness is now
|
|
blocked on runtime-owned release, test, and capture lifecycle evidence rather
|
|
than missing required Sai VN or optional Norn graph projection support.
|
|
- Unity scene now has the same kind of bounded `norn.graph` projection proof
|
|
for `embed.norn`. `NornGraphUnitySceneProjectionAdapter` emits a
|
|
scene-projection shell with the sidecar ABI, command boundary, document id,
|
|
and Norn semantic owner preserved; it does not calculate graph layout or make
|
|
graph-state decisions.
|
|
- Unity UI Toolkit now has a first-party `sai.vn` projection-adapter proof. The
|
|
runtime owns `IEveUiToolkitPluginProjectionAdapter`, registers
|
|
`SaiVisualNovelUiToolkitProjectionAdapter` through
|
|
`EveUiToolkitSurfaceOptions`, and declares support for `vn.stage`,
|
|
`story.choose`, `story.continue`, and `story.jump` in its runtime capability
|
|
manifest. Sai still owns story state and command semantics; Unity only lowers
|
|
the visual stage/dialogue/action surface and emits Eve command requests.
|
|
- Unity UI Toolkit now publishes a runtime-owned capability manifest at
|
|
`packages/org.gamecult.eve.unity-uitoolkit/eve-runtime-capability.json`. The
|
|
parity harness validates that manifest against
|
|
`gamecult.eve.runtime_capability.v1`, cross-checks supported features,
|
|
supported Sai, Norn, and TeX plugin projection declarations, command transport
|
|
schema, and incubation metadata, then exports the manifest path and validation
|
|
errors through the conformance report. Unity owns source-fallback projection
|
|
shells only; TeX parsing, typesetting, baseline metrics, and cached render
|
|
semantics remain EvePlugins-owned.
|
|
- Aetheria now consumes the exported conformance pack from its own working
|
|
directory through `scripts/run-aetheria-conformance-consumer-smoke.ps1`. The
|
|
smoke asserts the provider pack, `aetheria-world` fixture, `aetheria`
|
|
provider entry, and `aetheria-world-command-replay` scenario without reading
|
|
Eve's parity manifest or dirtying the Aetheria worktree.
|
|
- The Aetheria consumer smoke now also asserts frontend extraction boundaries:
|
|
web, Unity UI Toolkit, Unity scene, and Electron shell are covered generic
|
|
lowerings. Observed Aetheria Unity and Electron product paths remain
|
|
provider-owned split-handoff evidence to replace with provider-agnostic
|
|
EveUnity/EveElectron bodies where runtime code still lives in the wrong
|
|
place.
|
|
- The parity harness now runs a conformance consumer smoke against a copied
|
|
`artifacts/conformance/latest` layout, proving the export can be consumed
|
|
through `index.json` and `packs/*.json` without reading Eve's parity manifest.
|
|
- The parity harness now emits an `EveConformance`-shaped export under
|
|
`artifacts/conformance/latest`, with a top-level index and per-pack JSON
|
|
files for core, plugin, provider, and runtime consumers.
|
|
- Unity, Electron, and TUI plugin projection capability gaps are now explicitly
|
|
demoted. UI Toolkit, Unity scene, Electron, and compact TUI runtimes own
|
|
generic projection and command requests, while Sai, Norn, and TeX semantics
|
|
remain sidecar-plugin responsibilities. Runtimes only add projection shells or
|
|
lossy terminal fallbacks for capabilities a plugin advertises through Eve.
|
|
- Flutter and Unity now have runtime command-transport smoke evidence in the
|
|
parity report. Flutter emits `gamecult.eve.command.v1` intents from lowered
|
|
controls, and Unity command requests now carry the same command schema.
|
|
- Aetheria now has a provider scenario replay fixture advertised through its
|
|
provider advertisement. The parity harness validates advertised surfaces,
|
|
command boundary consumption, command intents, and provider-owned receipt
|
|
states without importing Aetheria internals into Eve.
|
|
- Aetheria's provider scenario now covers both `aetheria.daemon.game` and
|
|
`aetheria.daemon.editor` as provider-owned interactive world surfaces. The
|
|
Aetheria consumer smoke asserts editor ownership and the claimed TUI
|
|
terminal-grid lowering target instead of letting editor support hide behind
|
|
the game-surface scenario.
|
|
- The surface contract now states nested Norn and TeX placement as optional
|
|
composition, not Sai custody. The plugin-owner consumer can assert
|
|
provider-plugin requirement availability, so `sai.vn` remains required while
|
|
`norn.graph` and `tex.math` stay optional nested sidecar plugins. The browser
|
|
fallback catalog only advertises the Sai provider surface; independent Norn
|
|
and TeX availability is discovered through that provider's plugin
|
|
requirements and the separate plugin advertisements.
|
|
- Electron shell and compact TUI projection artifacts now carry the same
|
|
availability split as Unity projection artifacts: `sai.vn` projection is
|
|
required for the VN surface, while `norn.graph` and `tex.math` are
|
|
`optional-nested` independent sidecar plugin projections. This keeps
|
|
runtime projection support from becoming an implied Sai dependency story.
|
|
- Runtime projection schemas now type that boundary. Electron, TUI, Unity
|
|
scene, and Unity UI Toolkit projection schemas require plugin projections to
|
|
declare `availability`, `semanticOwner`, ABI schema, command boundary, and
|
|
capability claims; the local schema subset validators now resolve `$ref` and
|
|
enforce enum values so missing availability cannot hide in recursive runtime
|
|
capture trees.
|
|
- Browser reference fallback discovery now merges local catalog transport/URL
|
|
stubs with provider advertisement surface metadata instead of letting the
|
|
local stub erase semantics. `web/provider-advertisements.mjs` preserves
|
|
advertised `worldInteraction` and `requiresPlugins` for Aetheria and Sai
|
|
while keeping fixture-local loading paths, and both `web/surface.js` and the
|
|
layout probe consume that shared merge path.
|
|
- EveUnity's managed dependency story is now explicit machine-readable
|
|
lifecycle data instead of only prose. Each CultLib-owned Unity precompiled
|
|
dependency under `testContract.managedAssemblyDependencies[]` carries a
|
|
nested `dependencyContract` naming CultLib as source authority, NuGet as the
|
|
package source, the package/assembly identity, version policy, Unity
|
|
incubation resolution, and the EveUnity split handoff requirement. The
|
|
runtime capability schema, parity comparator, lifecycle smoke, and
|
|
runtime-owner conformance smoke all verify that boundary.
|
|
- Eve now has a non-Aetheria interactive world control fixture at
|
|
`web/fixtures/eve-world-smoke-surface.json` with an advertisement at
|
|
`web/fixtures/eve-world-smoke.provider-advertisement.json`. The local
|
|
provider catalog, web advertisement merge test, web layout probe, generic
|
|
conformance consumer, and runtime-owner consumer all assert that
|
|
`web-reference`, `unity-uitoolkit`, `unity-scene`, `electron-shell`, and
|
|
`tui` lower the same provider-owned world/command boundary without importing
|
|
Aetheria product state.
|
|
- That generic world fixture now has its own provider scenario at
|
|
`web/fixtures/eve-world-smoke-scenario.json`. The scenario advertises
|
|
accepted and denied command receipts through
|
|
`eve.world_smoke.command_receipt.v1`, so replay proof is no longer only an
|
|
Aetheria product concern.
|
|
- Runtime semantic capture now uses the same generic world control. UI Toolkit,
|
|
Unity scene, Electron shell, and TUI capture contracts keep Aetheria as the
|
|
primary pressure fixture while declaring `eve.world-smoke` as an additional
|
|
accepted provider surface. The parity harness emits separate
|
|
`eve-world-smoke` JSON projection/grid artifacts for those runtimes, and the
|
|
runtime-owner conformance smoke asserts them from the exported pack.
|
|
- Sai, Norn, and TeX now have plugin ABI fixtures for describe, validate,
|
|
project, lower, measure, and apply behavior. The parity harness validates
|
|
those fixtures against plugin manifests, so Eve proves the ABI shape without
|
|
owning plugin semantics.
|
|
- Plugin sidecar request/response schema names are now backed by Eve contract
|
|
documents. `gamecult.eve.plugin_abi.request.v1` and
|
|
`gamecult.eve.plugin_abi.response.v1` live under `schemas/`; Sai, Norn, and
|
|
TeX ABI fixtures must name those same schemas, and parity fails if a sidecar
|
|
advertises a request/response schema that is missing from the contract
|
|
catalog.
|
|
- Plugin sidecar receipt schema names are now backed by Eve contract
|
|
documents. `gamecult.eve.command_receipt.v1` is the generic command receipt
|
|
envelope for provider-owned acceptance/reconciliation, while
|
|
`gamecult.eve.plugin_receipt.v1` is the plugin-runtime diagnostic/proposed
|
|
state receipt envelope. Plugin ABI fixtures must match the sidecar-advertised
|
|
receipt schema, and parity fails if that schema is missing from the contract
|
|
catalog.
|
|
- Runtime release/capture request schema names are now backed by Eve contract
|
|
documents. `gamecult.eve.runtime_release_request.v1` and
|
|
`gamecult.eve.runtime_capture_request.v1` live under `schemas/`; runtime
|
|
lifecycle manifests must name catalog-backed request schemas, so release and
|
|
capture status cannot hide a missing wire contract.
|
|
- Conformance export now carries a root `schemaCatalog` and copies schema
|
|
documents under `schemas/` in the export. Plugin owners can assert
|
|
`gamecult.eve.plugin_abi.request.v1` and
|
|
`gamecult.eve.plugin_abi.response.v1` from the exported pack instead of
|
|
reading Eve's parity manifest to discover contract paths.
|
|
- EveConformance handoff now treats the exported schema catalog as part of the
|
|
split boundary. The handoff schema move set includes plugin, provider,
|
|
runtime, conformance, and ABI wire schemas, and the handoff smoke verifies the
|
|
latest conformance export copied those schema documents.
|
|
- Split-readiness reporting now exists for `EveFlutter` and `EveUnity`. The
|
|
parity report lists member runtime health, required plugin capability claims,
|
|
pending proofs, and blockers before either repo can graduate out of Eve
|
|
incubation.
|
|
- Direct2D is now recorded as an external Fensalir adapter spike, not an active
|
|
Eve runtime. Activation requires recorded `gamecult.eve.surface.v1` fixture
|
|
replay, command emission through the advertised boundary, and Direct2D frame
|
|
capture evidence from Fensalir.
|
|
- Fixture conformance metadata now lives beside each fixture and is validated by
|
|
the parity harness, so the corpus can move toward `EveConformance` without
|
|
relying only on Eve's local manifest layout.
|
|
- The browser reference now has an authority/staleness witness fixture. The
|
|
parity report verifies visible `fresh`, `accepted`, `stale`, `missing`,
|
|
`pending`, `denied`, `predicted`, and `reconciled` states, with provider and
|
|
renderer ownership kept separate.
|
|
- Command descriptor validation now runs for strict fixtures. Sai proves
|
|
`story.*`/`style.patch`; Aetheria proves the daemon command boundary; the web
|
|
lowerer resolves authored `action.command` through the shared Eve command
|
|
intent path.
|
|
- Provider plugin requirements now distinguish required parent semantics from
|
|
optional nested sidecar affordances at the contract layer. A Sai surface may
|
|
require `sai.vn`, but nested `norn.graph` and `tex.math` entries must keep
|
|
`requiredCapabilities` empty and advertise their nested affordances through
|
|
`optionalCapabilities`, preserving Norn and TeX as independent sidecar
|
|
plugins.
|
|
- Provider advertisement validation now runs in the parity harness.
|
|
- Repixelizer and Aetheria provider advertisements are checked against
|
|
`gamecult.eve.provider_advertisement.v1`.
|
|
- Aetheria has a minimal provider-owned interactive world fixture in Eve so the
|
|
browser oracle can prove the surface path without owning Aetheria truth.
|
|
|
|
## Stop Conditions
|
|
|
|
Stop adding features and update the map when:
|
|
|
|
- a runtime needs product knowledge to render a generic surface;
|
|
- a plugin fixture needs provider state to prove plugin behavior;
|
|
- a provider fixture becomes necessary for core Eve tests;
|
|
- a compatibility route becomes easier to use than a provider advertisement;
|
|
- a generated report says "active" while listing missing source symbols,
|
|
features, metadata, or plugin support;
|
|
- a split target exists but the owner, inputs, outputs, and release lifecycle
|
|
are still awkward to explain.
|
|
|
|
If the sentence "X owns Y so that Z remains true" cannot be written cleanly, the
|
|
migration step is not ready. The machine may still be useful. It is not yet
|
|
coherent.
|