# INI Panel Entry

This page is the short entry map for the INI panel UI shell.

## Shell Module

Use the shell-facing module when an outer UI needs entry links or a read-only
control view:

```js
import {
  INI_PANEL_ENTRIES,
  createControlPageBrowserApiManifest,
  createControlPageBrowserApiMethods,
  createControlPageBrowserApiSchema,
  createIniPanelLaunchApiManifest,
  createIniPanelLaunchApiSchema,
  createIniPanelLauncherLinkViewModel,
  createIniPanelShellControlPageContract,
  createIniPanelShellIntegrationManifest,
  createIniPanelShellIntegrationReadiness,
  createIniPanelShellIntegrationSchema,
  createIniPanelShellIntegrationWorkflowPlan,
  createIniPanelShellSessionHandoffCompatibilityReport,
  createIniPanelShellSessionHandoffDisplayViewModel,
  createIniPanelShellSessionHandoffRenderState,
  createIniPanelShellSessionHandoffSnapshot,
  createIniPanelShellSessionHandoffSummary,
  createIniPanelShellSessionHandoffSummarySchema,
  createIniPanelShellViewModel,
  getIniPanelEntryByHref,
  getVisibleIniPanelEntries,
  createMachineSessionControlPageController,
  createMachineSessionReadonlyStatus,
  createMachineSessionReadonlyStatusApiManifest,
  readMachineSessionReadonlyStatus,
  loadMachineSessionForControlPageWorkflow,
  createControlPageSessionLoadState,
  refreshMachineSessionControlPage,
  controlPageStatusText,
  renderMachineSessionControlView,
  isSupportedIniPanelControlPageApiManifest,
  isSupportedIniPanelLaunchApiManifest,
  isSupportedIniPanelShellIntegrationManifest,
  isSupportedIniPanelShellSessionHandoffSummary,
} from "../runtime/ui/ini-panel/ui-shell.js";
```

`ui-shell.js` re-exports the entry manifest, the read-only control-page
controller, the unified read-only status API, the readonly-status API manifest,
and the control-view renderer. It does not implement CNC behavior.

## Pages

| Page | Path | Role |
| --- | --- | --- |
| Launch | `runtime/ui/ini-panel/launch.html` | Read-only entry page for available panel surfaces. |
| Edit and run | `runtime/ui/ini-panel/index.html` | Editable INI panel and existing run workflow surface. |
| Read-only control view | `runtime/ui/ini-panel/control-page.html` | Read-only control view backed by the panel API. |

## Visible Entries

The visible launch entries come from `getVisibleIniPanelEntries()`:

| Entry id | Href | Title |
| --- | --- | --- |
| `edit-run` | `./index.html` | Open edit and run panel |
| `control-view` | `./control-page.html` | Open read-only control view |

Launcher pages can render links from `createIniPanelLauncherLinkViewModel()`
without reading manifest field names directly. Each item has `entryId`, `href`,
and `label`.

Outer shells can call `createIniPanelShellViewModel()` when they need one
read-only model with `pages`, `launcherLinks`, and `controlPage` helpers for
mounting the existing control-page controller, refresh workflow, and renderer.
Use `controlPage.readStatus` or `readMachineSessionReadonlyStatus()` when an
outer shell needs one stable read of `stateBundle`, `workflowStatus`,
`overview`, `controlView`, `session`, `runReadiness`, and `run`.
Use `createMachineSessionReadonlyStatusApiManifest()` or
`controlPage.readonlyStatusApiManifest` when you only need the API shape and
method names.
Use `createIniPanelShellControlPageContract()` or `controlPage.contract` when
an outer shell needs a fast contract check for `createController`,
`loadSessionState`, `readStatus`, `refresh`, `renderView`, the readonly status
manifest, and its status fields before mounting the embedded panel. The
contract lists readonly status fields for `stateBundle`, `workflowStatus`,
`overview`, `controlView`, `report`, `runReadiness`, `run`, `session`, and
`status`.
The browser control page also exposes this contract through
`linuxCncIniPanelControlPageApi.getControlPageContract()`, so real iframe-based
smokes can verify the same API shape before reading the embedded panel state.
Use `linuxCncIniPanelControlPageApi.getControlPageApiMethods()` when a browser
outer page needs the exact exposed method list before calling the read-only
control page API.
Use `createControlPageBrowserApiSchema()`,
`createControlPageBrowserApiManifest()`, or
`linuxCncIniPanelControlPageApi.getControlPageApiSchema()` and
`linuxCncIniPanelControlPageApi.getControlPageApiManifest()` when a browser
outer page needs a versioned control-page API description before reading the
embedded panel. Use `isSupportedIniPanelControlPageApiManifest()` or
`linuxCncIniPanelControlPageApi.isSupportedControlPageApiManifest()` for a
read-only compatibility predicate before consuming that manifest.
Use `linuxCncIniPanelControlPageApi.readControlPageStatus()` when a browser
outer page needs the same readonly status snapshot from the real embedded
control page after save/load session workflows.
The launch page exposes `linuxCncIniPanelLaunchApi.getControlPageApiMethods()`
from the same shell view-model so entry pages can consume the available
read-only control-page API list without loading the control-page iframe first.
Use `createIniPanelLaunchApiManifest()` or
`linuxCncIniPanelLaunchApi.getLaunchApiManifest()` when an outer shell needs a
single read-only description of launch methods, visible entries, target pages,
the control-page browser API methods, and OPFS/session persistence capabilities
for machine files, session snapshots, and read-only status.
Use `createIniPanelLaunchApiSchema()`,
`linuxCncIniPanelLaunchApi.getLaunchApiSchema()`, or `manifestVersion` when an
outer shell needs to check launch manifest compatibility before consuming these
fields.
Use `isSupportedIniPanelLaunchApiManifest()` or
`linuxCncIniPanelLaunchApi.isSupportedLaunchApiManifest()` for a read-only
compatibility predicate before using a launch manifest.
Use `createIniPanelShellIntegrationSchema()`,
`createIniPanelShellIntegrationManifest()`,
`linuxCncIniPanelLaunchApi.getShellIntegrationSchema()`, or
`linuxCncIniPanelLaunchApi.getShellIntegrationManifest()` when an outer shell
needs one versioned read of pages, launcher links, launch API metadata,
control-page API metadata, OPFS/session persistence capabilities, and current
compatibility status. Use `isSupportedIniPanelShellIntegrationManifest()` when
the outer shell needs to check that integration manifest before consuming it.
Use `createIniPanelShellIntegrationReadiness()` or
`linuxCncIniPanelLaunchApi.getShellIntegrationReadiness()` when the outer shell
needs a read-only `ready`/`blocked` status, failed check names, API names, and
counts for pages, methods, and persistence capabilities before mounting any
embedded control page.
Use `createIniPanelShellIntegrationWorkflowPlan()` when the outer shell needs a
Node-testable read-only plan for the control-page target, required launch and
control-page API methods, readiness gate, and readonly status handoff fields
before opening a browser frame.
Use `createIniPanelShellSessionHandoffSummary()` when the outer shell needs one
read-only display summary of readiness, target page, persistence capabilities,
readonly status fields, handoff methods, and blocking reasons. Browser shells
can read the same summary through
`linuxCncIniPanelLaunchApi.getShellSessionHandoffSummary()`.
Use `createIniPanelShellSessionHandoffSummarySchema()` or
`linuxCncIniPanelLaunchApi.getShellSessionHandoffSummarySchema()` for the
versioned summary shape, and `isSupportedIniPanelShellSessionHandoffSummary()`
or `linuxCncIniPanelLaunchApi.isSupportedShellSessionHandoffSummary()` before
consuming a summary from a browser shell.
Use `createIniPanelShellSessionHandoffCompatibilityReport()` or
`linuxCncIniPanelLaunchApi.getShellSessionHandoffCompatibilityReport()` when an
outer shell needs display-ready diagnostics for schema support, missing fields,
api/version mismatches, and current blocking reasons before consuming the
handoff summary.
Use `createIniPanelShellSessionHandoffDisplayViewModel()` or
`linuxCncIniPanelLaunchApi.getShellSessionHandoffDisplayViewModel()` when an
outer shell needs the same diagnostics as stable read-only label/value rows for
DOM display.
Use `createIniPanelShellSessionHandoffSnapshot()` or
`linuxCncIniPanelLaunchApi.getShellSessionHandoffSnapshot()` when an outer shell
needs one read-only API read that includes readiness, handoff summary,
compatibility report, and display view-model together.
Use `createIniPanelShellSessionHandoffRenderState()` or
`linuxCncIniPanelLaunchApi.getShellSessionHandoffRenderState()` when an outer
shell needs the snapshot compressed into launch-side DOM state with a status
line, stable rows, and `[data-handoff-shell]` phase/readiness flags. The launch
page renders `[data-handoff-status]` and `[data-handoff-rows]` from this helper
without adding control actions.
The browser workflow smoke
`tests/browser/ini_panel_shell_integration_workflow_smoke.html` verifies the
same external shell handoff: read integration manifest, pass readiness gate,
open the control page target, then read readonly machine-session status.

The control-page refresh workflow lives in
`runtime/ui/ini-panel/control-page-refresh-workflow.js`. Use
`refreshMachineSessionControlPage()` when an outer shell needs a structured
refresh result with `phase`, `statusText`, `view`, `renderResult`, and `error`.
`controlPageStatusText()` formats the already-observed panel status fields for
the read-only status line, and `createControlPageRefreshState()` is the stable
state-shape helper used by the workflow.

The control-page session workflow lives in
`runtime/ui/ini-panel/control-page-session-workflow.js`. Use
`loadMachineSessionForControlPageWorkflow()` when an outer shell needs a
read-only readiness snapshot for the embedded panel API and first control view.
`createControlPageSessionLoadState()` is the stable state-shape helper for
`waiting-panel`, `waiting-api`, `waiting-session`, `ready`, and `error` phases.

## Boundary

The entry shell only links pages and renders already-observed panel state. It
does not parse G-code, infer canonical events, or implement LinuxCNC-owned
tool, parameter, planner, or kinematics behavior.