Dicey Table

The Interface

The Status Bar

Edit Mode's footer strip — the save, draft and scene validity dots, the Problems panel they open, the project name, and the GitHub checkpoint and sync status.

On this page8 sections

The status bar (<footer className="em-statusbar">) is the strip across the very bottom of Edit Mode. Every value on it is derived from state that some other control owns, and it answers one question at a glance: is it safe to walk away from this scene right now?

When the answer is no, each indicator is also a button: click any of them to open the Problems panel and see exactly what is wrong.

The status bar footer showing the Saved/Valid draft/Scene valid status dots and the current project name (open full size)

The problem count#

After the three dots, N errors · M warnings counts the Problems panel's live rows — the draft, scene, GitHub, publishing and last-operation problems, which clear themselves when you fix them — the same totals as the save pill's badge and the View ▸ Problems (N) menu item. The tab's diagnostics log is listed in the panel but not counted (see Diagnostics from the rest of the tab). It is a button that opens the panel whenever the panel has anything to list.

The three status dots#

Three coloured dots (green em-status-ok, amber em-status-warn, red em-status-error), left to right:

Dot States What it reflects
Save state Saved / Dirty changes / Invalid draft The same saveStateLabel the topbar's save-state pill shows — whether the draft on the server matches what is in front of you, and whether any open Deck/Model/File/Script tab still holds edits its backing file doesn't have. Clickable the same way: Dirty changes opens the Unsaved changes dialog.
Draft validation Validation pending / Valid draft / Invalid draft The server's validation result for the whole draft (manifest + scene + script text), returned in response.draft.validation whenever the project loads or saves. Validation pending means no server response has come back yet — this dot does not recompute itself locally.
Scene validation Scene pending / Scene valid / Scene invalid A live, client-side re-check: editSceneSnapshotSchema.safeParse(sceneDraft), recomputed on every edit to the in-memory scene draft. This is what tells you immediately that an edit broke the schema, without waiting on a round trip.

The draft validation and scene validation dots can disagree, and that is meaningful: the scene dot reacts the instant you make an edit; the draft dot only refreshes on the next load or save, so it can still show yesterday's Valid draft for a few seconds after you have just made the scene locally invalid. If you need to know right now whether your last edit is schema-valid, read the scene dot, not the draft dot.

Save Draft itself does a third, stricter check before it writes anything — see Save Draft — so a Saved state on this bar always implies the document passed that check at the time it was saved, even if the underlying dots have since drifted.

Project and GitHub status#

  • Project: {name}, or No project before one loads.
  • For a GitHub-linked mod only, two more indicators — one for each direction of travel.

↳ {repo} — the checkpoint dot (pushes OUT)#

A titled span showing either the last WIP checkpoint status message (Checkpointed to {repo}@wip. or a failure with retry note) or, before the first checkpoint of the session, ↳ {repo}. This is the same background auto-checkpoint mechanism described in Publish to GitHub — it pushes your working tree to the repository's wip branch, separate from an explicit Publish.

⇅ Synced — the sync dot (pulls IN)#

Every time a GitHub-linked project opens, the repository's file tree is re-synced down into this device's local working copy: anything missing is downloaded, anything that changed upstream is updated, and anything you changed locally is left alone. This dot reports that pull.

  • ⇅ Synced (green) — every file is either identical to the repository's copy or has already been reconciled with it.
  • ⇅ N conflicts (amber) — N files, or items of your mod's details, changed both here and on GitHub. Nothing has been overwritten in either direction; the sync deliberately declines to guess.

Unlike the other indicators, this one is a button whether or not there is a problem, because it is also the only way to reach the reset described below. Clicking it opens the GitHub sync dialog.

Resolving a conflict

Each conflicted file gets a row. Expanding it lays the two versions side by side with the facts that separate them — byte size, when your copy was last edited, when the repository's copy was last committed, and each side's content hash — plus a preview of both where the bytes can be shown honestly (text files render as text, images as thumbnails, anything else reports its size and hash). Then choose per file:

  • Keep local — your copy stands.
  • Use GitHub — the repository's copy replaces yours. Your version is gone.

Whichever you choose is recorded. The same file is not raised again until one side changes again, so resolving a conflict actually clears it rather than deferring it to the next time you open the project. Keep all local / Use all from GitHub set every row at once; Apply writes only the rows you decided.

Sync now re-runs the pull without waiting for a reload — useful after pushing from elsewhere.

Merging mod details

Your mod's details in diceytable.mod.json (name, credits, screenshots, sound sets, plugins, load-on-demand files and the rest of the manifest) are not synced as a file. They are merged, one field at a time, and one entry at a time inside lists such as credits and screenshots.

The editor remembers the manifest as it last agreed with the repository, and compares both sides against that:

What changed What happens
Only your draft (for example, an import added a credit you have not published yet) Nothing to do. Your draft is ahead, and the next Publish ships it.
Only GitHub (for example, another device published, or Publish added a derived assetRepos entry) Taken into your draft automatically. The status line says what was taken; save the draft to keep it.
Both, to the same result Nothing to do.
Both, differently Listed at the top of the dialog under Mod details changed here and on GitHub.

Each listed item shows This draft and GitHub side by side as two cards. Click the card you want to keep. Before either change shows the version both sides started from. You can decide per item, per field (All draft / All GitHub), or for everything at once. Apply … and save writes your choices into the draft and saves it. Anything you leave undecided keeps your draft's value, and you are asked again on the next sync.

Two things never appear here. assets is derived from your files on every save, so the file rows above cover it. A change to capabilities made on GitHub is always listed rather than taken automatically, because capabilities are disclosed to every player before they join.

The first sync after this feature arrives has no remembered version to compare against, so it keeps everything from both sides and lists only fields that both sides hold with different values. After one decision it knows the difference.

Reset local copy from GitHub

The escape hatch, in its own section at the bottom of the dialog and gated behind typing the repository name. It deletes this device's entire local working copy and re-downloads every file from the branch. Anything you edited locally and never published is lost.

What it does not touch: your manifest and your scene. Those live on the server as the project's draft, not in the local file tree, so Mod Details and the viewport survive a reset untouched — the two files that represent them in the project folder are rewritten from the draft as the last step.

The Problems panel#

A status dot tells you that something is wrong. The Problems panel tells you what.

Whenever there is anything to report, every indicator on this bar — and the topbar's save-state pill, which grows a red/amber count badge — becomes a button that toggles a panel anchored above the bar. All of them open the same panel, so you never have to work out which indicator owns a given failure. With nothing to report they stay inert text and are not focusable, and the panel closes itself the moment the last problem clears.

Each row carries a severity icon, the message, the source it came from, the path into the offending document where one is known (objects[3].scale), and the remedy. Errors sort above warnings; within a severity the order is stable, so the list does not reshuffle under your pointer as unrelated state changes.

Source What it reports
Scene Every issue from the live editSceneSnapshotSchema re-check, one row per Zod issue, each with its path. Listed first: an invalid scene is the failure that actually loses work, because Save Draft refuses to write a scene that will not parse back.
Draft The server's compatibility issues for the whole draft, carrying their own severity and code.
GitHub No repository linked (warning), GitHub not connected (error), and the last WIP checkpoint failed (error, with the underlying message). Sync conflicts are not here — they are not failures, and they have their own dialog.
Publishing The Mod Details fields a listing needs before you can publish — the same list the Publish dialog shows.
Last operation The most recent failed action, the same text the status message shows.

Diagnostics from the rest of the tab#

Below those rows the panel also lists the tab's diagnostics — failures that happen somewhere other than the draft and used to be visible only in the browser console: Script compile errors, the Script safety scanner, GitHub sync conflicts and files that failed to sync, Assets that could not be resolved (including a missing file served as HTML), Model import, the import credit gate, GPU device loss, Physics halts and uncaught errors. Each row names its source and file (with the line when there is one), and a failure that repeats shows once with a (×N) count rather than flooding the list. Warnings and errors only, newest first, at most 100 rows.

These rows are history rather than live state: fixing a script does not remove its old compile error from the list (the draft rows above do clear themselves). That is why they sit under a Recent diagnostics — informational heading and are not counted by the status bar, the save pill or the menu: a count nothing can bring back to zero would keep the pill an error button for the rest of the session. They only make the panel openable. An AI agent connected to the tab reads the same list through diagnostics_get.

Rows you can fix from here#

Most rows tell you what to do. A few can do it for you, and carry a button.

Manifest references an asset that is not in the draft — Drop from manifest removes that one dangling entry from diceytable.mod.json. This is a blocking error, and it used to be a dead end: the remedy was to edit the manifest, and diceytable.mod.json is generated on save and is not in the project explorer, so there was no way to do it. Removing a declaration for a file that is demonstrably not there is safe — nothing can load bytes that do not exist, and re-importing the file re-declares it the normal way. If you meant to keep the asset, put the file back instead of clicking the button.

Save Draft also reconciles the manifest against the project tree, so in most cases saving clears this row on its own. The button is for when you want it gone now, or when saving is what the error is blocking.

The GitHub rows are the reason this panel exists. A checkpoint that cannot reach GitHub — an expired authorization, a permission change, a network failure — used to fail into a status string that the next message overwrote, leaving a mod that looked saved and was not. That is how a working tree drifts off the branch it publishes from. Now it is a standing error you can read at any time, and it names the repository it could not reach.

The AI agent indicator#

The Agent connected: Claude Code indicator is not on this bar. It sits at the bottom-left of the viewport, where its menu (Pause, Disconnect, Activity…) has room to open: see The AI agent indicator.

The Problems panel's diagnostics are what a connected agent reads through diagnostics_get, so the rows the panel lists are the same ones it sees (the agent also sees the log entries this bar does not count).

The status message#

The rightmost, and widest, element. It shows the most recent error (styled red) if one is set, or otherwise the most recent informational status message, or Ready. when neither is set. Nearly every action elsewhere in Edit Mode — saving, restoring a version, uploading an asset, compressing a texture — writes its outcome here, so this is the first place to look after clicking something that appears to do nothing.

What the status bar writes#

Nothing about your scene. Every element is a projection of state owned elsewhere — the topbar's save/undo actions, the Versions panel, the asset explorer's uploads, and the background WIP checkpoint. The only thing clicking a dot changes is whether the Problems panel is open.

See also#

  • The Topbar — the save-state pill this bar's first dot mirrors, and Save Draft's own validation step.
  • Publish to GitHub — the WIP-checkpoint and full publish flow behind the GitHub status span.
  • Where my files live — what is in the local working copy, what is on the server, and what a reset therefore does and does not delete.

Did this page answer your question?