Code Queue Review
590 lines
19 KiB
JavaScript
590 lines
19 KiB
JavaScript
const SOURCE_KIND_ORDER = Object.freeze(["SOURCE", "DRY-RUN", "DEV-LIVE", "BLOCKED"]);
|
|
|
|
export const M3_TRUSTED_CHAIN = Object.freeze({
|
|
fromResourceId: "res_boxsimu_1",
|
|
fromPort: "DO1",
|
|
patchPanelServiceId: "hwlab-patch-panel",
|
|
toResourceId: "res_boxsimu_2",
|
|
toPort: "DI1"
|
|
});
|
|
|
|
export const hardwareEvidencePanelSourceLegend = Object.freeze([
|
|
{
|
|
sourceKind: "SOURCE",
|
|
label: "SOURCE",
|
|
detail: "Static contract, topology, or checked-in source material."
|
|
},
|
|
{
|
|
sourceKind: "DRY-RUN",
|
|
label: "DRY-RUN",
|
|
detail: "Fixture or local validation that never touched the live hardware path."
|
|
},
|
|
{
|
|
sourceKind: "DEV-LIVE",
|
|
label: "DEV-LIVE",
|
|
detail: "Trusted DEV observation from the M3 closed loop."
|
|
},
|
|
{
|
|
sourceKind: "BLOCKED",
|
|
label: "BLOCKED",
|
|
detail: "Cannot promote to trusted evidence until DEV-LIVE M3 exists."
|
|
}
|
|
]);
|
|
|
|
export const defaultHardwareEvidencePanelData = Object.freeze({
|
|
title: "Hardware Evidence",
|
|
subtitle: "Right-side workbench panel for the M3 trusted loop",
|
|
sourceKind: "SOURCE",
|
|
observedAt: null,
|
|
statuses: [
|
|
{
|
|
id: "res_boxsimu_1",
|
|
label: "BOX-SIMU 1",
|
|
kind: "BOX-SIMU",
|
|
role: "source DO1",
|
|
status: "degraded",
|
|
sourceKind: "BLOCKED",
|
|
detail: "No DEV-LIVE DO1 transition evidence is attached yet."
|
|
},
|
|
{
|
|
id: "gateway_simu_1",
|
|
label: "Gateway-SIMU",
|
|
kind: "Gateway-SIMU",
|
|
role: "read-only route",
|
|
status: "degraded",
|
|
sourceKind: "SOURCE",
|
|
detail: "Gateway shape is visible, but the M3 live loop is not proven."
|
|
},
|
|
{
|
|
id: "hwlab-patch-panel",
|
|
label: "Patch Panel",
|
|
kind: "Patch Panel",
|
|
role: "wiring authority",
|
|
status: "blocked",
|
|
sourceKind: "BLOCKED",
|
|
detail: "Waiting for a DEV-LIVE active link through hwlab-patch-panel."
|
|
},
|
|
{
|
|
id: "res_boxsimu_2",
|
|
label: "BOX-SIMU 2",
|
|
kind: "BOX-SIMU",
|
|
role: "target DI1",
|
|
status: "degraded",
|
|
sourceKind: "BLOCKED",
|
|
detail: "No DEV-LIVE DI1 observation is attached yet."
|
|
}
|
|
],
|
|
chain: {
|
|
...M3_TRUSTED_CHAIN,
|
|
status: "blocked",
|
|
sourceKind: "BLOCKED",
|
|
detail: "res_boxsimu_1:DO1 -> hwlab-patch-panel -> res_boxsimu_2:DI1 is not DEV-LIVE proven."
|
|
},
|
|
records: {
|
|
operations: [
|
|
{
|
|
id: "op_m3_waiting_dev_live",
|
|
status: "blocked",
|
|
sourceKind: "BLOCKED",
|
|
summary: "Readonly placeholder; no hardware operation is issued from this panel."
|
|
}
|
|
],
|
|
audit: [
|
|
{
|
|
id: "audit_m3_panel_contract",
|
|
status: "recorded",
|
|
sourceKind: "SOURCE",
|
|
summary: "Workbench panel contract requires read-only evidence before trust promotion."
|
|
}
|
|
],
|
|
evidence: [
|
|
{
|
|
id: "evi_m3_dry_run_fixture",
|
|
status: "dry-run",
|
|
sourceKind: "DRY-RUN",
|
|
summary: "Local smoke proves shape only; it is not DEV-LIVE trusted evidence."
|
|
}
|
|
]
|
|
},
|
|
controls: [
|
|
{
|
|
id: "m3-do1-toggle",
|
|
label: "DO1 trigger",
|
|
disabled: true,
|
|
reason: "not wired / readonly / waiting for DEV-LIVE M3 loop"
|
|
},
|
|
{
|
|
id: "patch-panel-apply",
|
|
label: "Apply wiring",
|
|
disabled: true,
|
|
reason: "not wired / readonly / waiting for DEV-LIVE M3 loop"
|
|
}
|
|
]
|
|
});
|
|
|
|
export function createHardwareEvidencePanelModel(data = {}) {
|
|
const statuses = normalizeStatuses(data.statuses ?? defaultHardwareEvidencePanelData.statuses);
|
|
const records = normalizeRecords(data.records ?? defaultHardwareEvidencePanelData.records);
|
|
const controls = normalizeControls(data.controls ?? defaultHardwareEvidencePanelData.controls);
|
|
const chain = normalizeChain(data.chain ?? defaultHardwareEvidencePanelData.chain);
|
|
const runtimeDurability = normalizeRuntimeDurability(data.runtime ?? data.runtimeSummary);
|
|
const hasTrustedDevLiveEvidence = records.evidence.some(
|
|
(record) =>
|
|
record.sourceKind === "DEV-LIVE" &&
|
|
["pass", "passed", "verified", "succeeded", "trusted"].includes(record.status)
|
|
);
|
|
const chainMatches = isRequiredM3Chain(chain);
|
|
const trustStatus = runtimeDurability.ready && hasTrustedDevLiveEvidence && chainMatches ? "verified" : "blocked";
|
|
const trustTone = trustStatus === "verified" ? "trusted" : "degraded";
|
|
const sourceKind = trustStatus === "verified" ? "DEV-LIVE" : "BLOCKED";
|
|
const blockedReason = runtimeDurability.ready
|
|
? "Current data lacks real DEV-LIVE evidence; the workbench must render BLOCKED/degraded, never green."
|
|
: runtimeDurability.reason;
|
|
const guardedChain = {
|
|
...chain,
|
|
status: trustStatus === "verified" ? normalizeStatus(chain.status, "verified") : "blocked",
|
|
sourceKind,
|
|
detail:
|
|
trustStatus === "verified"
|
|
? chain.detail
|
|
: `BLOCKED: ${blockedReason}`
|
|
};
|
|
|
|
return {
|
|
title: data.title ?? defaultHardwareEvidencePanelData.title,
|
|
subtitle: data.subtitle ?? defaultHardwareEvidencePanelData.subtitle,
|
|
observedAt: data.observedAt ?? defaultHardwareEvidencePanelData.observedAt,
|
|
sourceKind,
|
|
sourceLegend: hardwareEvidencePanelSourceLegend,
|
|
trustedLoop: {
|
|
milestone: "M3",
|
|
status: trustStatus,
|
|
tone: trustTone,
|
|
sourceKind,
|
|
runtimeDurability,
|
|
reason:
|
|
trustStatus === "verified"
|
|
? "DEV-LIVE evidence is attached to the required M3 chain."
|
|
: blockedReason
|
|
},
|
|
statuses: statuses.map((status) => ({
|
|
...status,
|
|
status: trustStatus === "verified" || status.status === "blocked" ? status.status : "degraded"
|
|
})),
|
|
chain: guardedChain,
|
|
records,
|
|
controls: controls.map((control) => ({
|
|
...control,
|
|
disabled: true,
|
|
reason: control.reason || "not wired / readonly / waiting for DEV-LIVE M3 loop"
|
|
}))
|
|
};
|
|
}
|
|
|
|
export function renderHardwareEvidencePanel(container, data = {}) {
|
|
if (!container || typeof container.replaceChildren !== "function") {
|
|
throw new TypeError("renderHardwareEvidencePanel requires a DOM container with replaceChildren().");
|
|
}
|
|
|
|
const model = createHardwareEvidencePanelModel(data);
|
|
const doc = container.ownerDocument ?? globalThis.document;
|
|
const root = element(doc, "aside", "hwlab-workbench-hardware-panel");
|
|
root.dataset.status = model.trustedLoop.status;
|
|
root.dataset.sourceKind = model.sourceKind;
|
|
root.setAttribute("aria-label", "Workbench hardware evidence panel");
|
|
|
|
root.append(panelStyles(doc));
|
|
root.append(renderHeader(doc, model));
|
|
root.append(renderStatusSection(doc, model));
|
|
root.append(renderChainSection(doc, model.chain));
|
|
root.append(renderRecordsSection(doc, model.records));
|
|
root.append(renderControlsSection(doc, model.controls));
|
|
root.append(renderLegendSection(doc, model.sourceLegend));
|
|
|
|
container.replaceChildren(root);
|
|
return { element: root, model };
|
|
}
|
|
|
|
function normalizeStatuses(statuses) {
|
|
return arrayFrom(statuses).map((status) => ({
|
|
id: stringOr(status.id, "unknown-resource"),
|
|
label: stringOr(status.label, status.id ?? "Unknown resource"),
|
|
kind: stringOr(status.kind, "resource"),
|
|
role: stringOr(status.role, "status"),
|
|
status: normalizeStatus(status.status, "degraded"),
|
|
sourceKind: normalizeSourceKind(status.sourceKind),
|
|
detail: stringOr(status.detail, "No detail provided.")
|
|
}));
|
|
}
|
|
|
|
function normalizeRecords(records) {
|
|
return {
|
|
operations: normalizeRecordList(records.operations),
|
|
audit: normalizeRecordList(records.audit),
|
|
evidence: normalizeRecordList(records.evidence)
|
|
};
|
|
}
|
|
|
|
function normalizeRuntimeDurability(runtime) {
|
|
if (!runtime || typeof runtime !== "object" || Array.isArray(runtime)) {
|
|
return {
|
|
ready: false,
|
|
adapter: "memory",
|
|
durable: false,
|
|
liveRuntimeEvidence: false,
|
|
reason: "runtime.durable=false; memory/non-durable runtime cannot render DEV-LIVE or durable evidence."
|
|
};
|
|
}
|
|
|
|
const ready =
|
|
runtime.durable === true &&
|
|
runtime.ready !== false &&
|
|
runtime.liveRuntimeEvidence === true &&
|
|
!["blocked", "degraded", "failed"].includes(String(runtime.status ?? "").toLowerCase());
|
|
return {
|
|
ready,
|
|
adapter: stringOr(runtime.adapter, "unknown"),
|
|
durable: runtime.durable === true,
|
|
durableRequested: runtime.durableRequested === true,
|
|
liveRuntimeEvidence: runtime.liveRuntimeEvidence === true,
|
|
reason: ready
|
|
? "Durable runtime readiness is proven."
|
|
: `runtime durable adapter is not ready (adapter=${stringOr(runtime.adapter, "unknown")}, durable=${runtime.durable === true}); trusted records stay BLOCKED.`
|
|
};
|
|
}
|
|
|
|
function normalizeRecordList(records) {
|
|
return arrayFrom(records).map((record) => ({
|
|
id: stringOr(record.id ?? record.operationId ?? record.auditId ?? record.evidenceId, "record"),
|
|
status: normalizeStatus(record.status ?? record.outcome, "recorded"),
|
|
sourceKind: normalizeSourceKind(record.sourceKind),
|
|
summary: stringOr(record.summary ?? record.uri ?? record.kind, "No summary provided.")
|
|
}));
|
|
}
|
|
|
|
function normalizeControls(controls) {
|
|
return arrayFrom(controls).map((control) => ({
|
|
id: stringOr(control.id, "readonly-control"),
|
|
label: stringOr(control.label, "Readonly control"),
|
|
disabled: true,
|
|
reason: stringOr(control.reason, "not wired / readonly / waiting for DEV-LIVE M3 loop")
|
|
}));
|
|
}
|
|
|
|
function normalizeChain(chain) {
|
|
return {
|
|
fromResourceId: stringOr(chain.fromResourceId, M3_TRUSTED_CHAIN.fromResourceId),
|
|
fromPort: stringOr(chain.fromPort, M3_TRUSTED_CHAIN.fromPort),
|
|
patchPanelServiceId: stringOr(chain.patchPanelServiceId, M3_TRUSTED_CHAIN.patchPanelServiceId),
|
|
toResourceId: stringOr(chain.toResourceId, M3_TRUSTED_CHAIN.toResourceId),
|
|
toPort: stringOr(chain.toPort, M3_TRUSTED_CHAIN.toPort),
|
|
status: normalizeStatus(chain.status, "blocked"),
|
|
sourceKind: normalizeSourceKind(chain.sourceKind),
|
|
detail: stringOr(chain.detail, "Waiting for M3 evidence.")
|
|
};
|
|
}
|
|
|
|
function isRequiredM3Chain(chain) {
|
|
return (
|
|
chain.fromResourceId === M3_TRUSTED_CHAIN.fromResourceId &&
|
|
chain.fromPort === M3_TRUSTED_CHAIN.fromPort &&
|
|
chain.patchPanelServiceId === M3_TRUSTED_CHAIN.patchPanelServiceId &&
|
|
chain.toResourceId === M3_TRUSTED_CHAIN.toResourceId &&
|
|
chain.toPort === M3_TRUSTED_CHAIN.toPort
|
|
);
|
|
}
|
|
|
|
function normalizeStatus(status, fallback) {
|
|
const value = String(status ?? fallback).trim().toLowerCase();
|
|
return value || fallback;
|
|
}
|
|
|
|
function normalizeSourceKind(sourceKind) {
|
|
const value = String(sourceKind ?? "SOURCE").trim().toUpperCase();
|
|
return SOURCE_KIND_ORDER.includes(value) ? value : "SOURCE";
|
|
}
|
|
|
|
function arrayFrom(value) {
|
|
return Array.isArray(value) ? value : [];
|
|
}
|
|
|
|
function stringOr(value, fallback) {
|
|
const text = value === undefined || value === null ? "" : String(value).trim();
|
|
return text || fallback;
|
|
}
|
|
|
|
function renderHeader(doc, model) {
|
|
const header = element(doc, "header", "hwlab-panel-header");
|
|
const titleWrap = element(doc, "div", "hwlab-panel-title-wrap");
|
|
titleWrap.append(textElement(doc, "p", "hwlab-panel-kicker", "M3 trusted loop"));
|
|
titleWrap.append(textElement(doc, "h2", "hwlab-panel-title", model.title));
|
|
titleWrap.append(textElement(doc, "p", "hwlab-panel-subtitle", model.subtitle));
|
|
header.append(titleWrap);
|
|
header.append(badge(doc, model.sourceKind, model.trustedLoop.tone));
|
|
header.append(textElement(doc, "p", `hwlab-panel-trust tone-${toneClass(model.trustedLoop.tone)}`, model.trustedLoop.reason));
|
|
return header;
|
|
}
|
|
|
|
function renderStatusSection(doc, model) {
|
|
const section = panelSection(doc, "Hardware status", "BOX-SIMU / Gateway-SIMU / Patch Panel");
|
|
const grid = element(doc, "div", "hwlab-status-grid");
|
|
for (const item of model.statuses) {
|
|
const card = element(doc, "article", `hwlab-status-card tone-${toneClass(item.status)}`);
|
|
card.dataset.sourceKind = item.sourceKind;
|
|
const head = element(doc, "div", "hwlab-status-card-head");
|
|
head.append(textElement(doc, "strong", "hwlab-status-label", item.label));
|
|
head.append(badge(doc, item.sourceKind, item.sourceKind));
|
|
card.append(head);
|
|
card.append(textElement(doc, "span", "hwlab-status-kind", `${item.kind} / ${item.role}`));
|
|
card.append(textElement(doc, "span", `hwlab-status-value tone-${toneClass(item.status)}`, item.status.toUpperCase()));
|
|
card.append(textElement(doc, "p", "hwlab-status-detail", item.detail));
|
|
grid.append(card);
|
|
}
|
|
section.append(grid);
|
|
return section;
|
|
}
|
|
|
|
function renderChainSection(doc, chain) {
|
|
const section = panelSection(doc, "M3 chain", "Required route");
|
|
const chainLine = element(doc, "div", `hwlab-chain-line tone-${toneClass(chain.status)}`);
|
|
chainLine.append(chainNode(doc, `${chain.fromResourceId}:${chain.fromPort}`, "BOX-SIMU DO1"));
|
|
chainLine.append(textElement(doc, "span", "hwlab-chain-arrow", "->"));
|
|
chainLine.append(chainNode(doc, chain.patchPanelServiceId, "Patch Panel"));
|
|
chainLine.append(textElement(doc, "span", "hwlab-chain-arrow", "->"));
|
|
chainLine.append(chainNode(doc, `${chain.toResourceId}:${chain.toPort}`, "BOX-SIMU DI1"));
|
|
section.append(chainLine);
|
|
const detail = element(doc, "div", "hwlab-chain-detail");
|
|
detail.append(badge(doc, chain.sourceKind, chain.status));
|
|
detail.append(textElement(doc, "p", "hwlab-chain-copy", chain.detail));
|
|
section.append(detail);
|
|
return section;
|
|
}
|
|
|
|
function renderRecordsSection(doc, records) {
|
|
const section = panelSection(doc, "Records", "operation / audit / evidence summary");
|
|
const columns = element(doc, "div", "hwlab-record-columns");
|
|
for (const [label, items] of [
|
|
["operation", records.operations],
|
|
["audit", records.audit],
|
|
["evidence", records.evidence]
|
|
]) {
|
|
const column = element(doc, "article", "hwlab-record-column");
|
|
column.append(textElement(doc, "h4", "hwlab-record-heading", `${label} (${items.length})`));
|
|
const list = element(doc, "ul", "hwlab-record-list");
|
|
for (const item of items) {
|
|
const row = element(doc, "li", "hwlab-record-item");
|
|
const head = element(doc, "div", "hwlab-record-head");
|
|
head.append(textElement(doc, "span", "hwlab-record-id", item.id));
|
|
head.append(badge(doc, item.sourceKind, item.sourceKind));
|
|
row.append(head);
|
|
row.append(textElement(doc, "span", `hwlab-record-status tone-${toneClass(item.status)}`, item.status));
|
|
row.append(textElement(doc, "p", "hwlab-record-summary", item.summary));
|
|
list.append(row);
|
|
}
|
|
column.append(list);
|
|
columns.append(column);
|
|
}
|
|
section.append(columns);
|
|
return section;
|
|
}
|
|
|
|
function renderControlsSection(doc, controls) {
|
|
const section = panelSection(doc, "Controls", "readonly placeholders");
|
|
const list = element(doc, "div", "hwlab-control-list");
|
|
for (const control of controls) {
|
|
const row = element(doc, "div", "hwlab-control-row");
|
|
const button = element(doc, "button", "hwlab-control-button");
|
|
button.type = "button";
|
|
button.disabled = true;
|
|
button.dataset.controlId = control.id;
|
|
button.textContent = control.label;
|
|
row.append(button);
|
|
row.append(textElement(doc, "span", "hwlab-control-reason", control.reason));
|
|
list.append(row);
|
|
}
|
|
section.append(list);
|
|
return section;
|
|
}
|
|
|
|
function renderLegendSection(doc, legend) {
|
|
const section = panelSection(doc, "Source labels", "promotion boundary");
|
|
const list = element(doc, "dl", "hwlab-source-legend");
|
|
for (const item of legend) {
|
|
list.append(textElement(doc, "dt", "hwlab-source-kind", item.label));
|
|
list.append(textElement(doc, "dd", "hwlab-source-detail", item.detail));
|
|
}
|
|
section.append(list);
|
|
return section;
|
|
}
|
|
|
|
function panelSection(doc, title, caption) {
|
|
const section = element(doc, "section", "hwlab-panel-section");
|
|
const head = element(doc, "div", "hwlab-section-head");
|
|
head.append(textElement(doc, "h3", "hwlab-section-title", title));
|
|
head.append(textElement(doc, "span", "hwlab-section-caption", caption));
|
|
section.append(head);
|
|
return section;
|
|
}
|
|
|
|
function chainNode(doc, value, label) {
|
|
const node = element(doc, "span", "hwlab-chain-node");
|
|
node.append(textElement(doc, "strong", "hwlab-chain-value", value));
|
|
node.append(textElement(doc, "small", "hwlab-chain-label", label));
|
|
return node;
|
|
}
|
|
|
|
function badge(doc, value, tone) {
|
|
const item = element(doc, "span", `hwlab-source-badge tone-${toneClass(tone ?? value)}`);
|
|
item.textContent = value;
|
|
return item;
|
|
}
|
|
|
|
function textElement(doc, tagName, className, text) {
|
|
const item = element(doc, tagName, className);
|
|
item.textContent = text;
|
|
return item;
|
|
}
|
|
|
|
function element(doc, tagName, className) {
|
|
const item = doc.createElement(tagName);
|
|
if (className) item.className = className;
|
|
return item;
|
|
}
|
|
|
|
function toneClass(value) {
|
|
return String(value ?? "unknown")
|
|
.trim()
|
|
.replace(/[^a-z0-9_-]/giu, "-")
|
|
.toLowerCase();
|
|
}
|
|
|
|
function panelStyles(doc) {
|
|
const style = element(doc, "style");
|
|
style.textContent = `
|
|
.hwlab-workbench-hardware-panel {
|
|
box-sizing: border-box;
|
|
display: grid;
|
|
gap: 12px;
|
|
min-width: 320px;
|
|
max-width: 420px;
|
|
padding: 14px;
|
|
color: #d9e2df;
|
|
background: #151a1d;
|
|
border-left: 1px solid #364246;
|
|
font: 13px/1.45 ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
|
|
}
|
|
.hwlab-workbench-hardware-panel *, .hwlab-workbench-hardware-panel *::before, .hwlab-workbench-hardware-panel *::after {
|
|
box-sizing: border-box;
|
|
}
|
|
.hwlab-panel-header, .hwlab-panel-section {
|
|
display: grid;
|
|
gap: 10px;
|
|
padding: 12px;
|
|
background: #1d2427;
|
|
border: 1px solid #364246;
|
|
border-radius: 6px;
|
|
}
|
|
.hwlab-panel-title-wrap {
|
|
display: grid;
|
|
gap: 2px;
|
|
}
|
|
.hwlab-section-head, .hwlab-status-card-head, .hwlab-record-head, .hwlab-control-row, .hwlab-chain-detail {
|
|
display: flex;
|
|
gap: 8px;
|
|
align-items: center;
|
|
justify-content: space-between;
|
|
}
|
|
.hwlab-panel-title, .hwlab-section-title, .hwlab-record-heading, .hwlab-panel-kicker, .hwlab-panel-subtitle, .hwlab-panel-trust, .hwlab-status-detail, .hwlab-chain-copy, .hwlab-record-summary {
|
|
margin: 0;
|
|
}
|
|
.hwlab-panel-title {
|
|
font-size: 18px;
|
|
font-weight: 700;
|
|
}
|
|
.hwlab-panel-kicker, .hwlab-section-caption, .hwlab-status-kind, .hwlab-chain-label, .hwlab-panel-subtitle, .hwlab-source-detail, .hwlab-control-reason {
|
|
color: #95a6a3;
|
|
}
|
|
.hwlab-source-badge {
|
|
flex: 0 0 auto;
|
|
padding: 2px 7px;
|
|
border: 1px solid currentColor;
|
|
border-radius: 999px;
|
|
font-size: 11px;
|
|
font-weight: 700;
|
|
letter-spacing: 0;
|
|
}
|
|
.hwlab-status-grid, .hwlab-record-columns {
|
|
display: grid;
|
|
gap: 8px;
|
|
}
|
|
.hwlab-status-card, .hwlab-record-column, .hwlab-record-item, .hwlab-chain-line {
|
|
display: grid;
|
|
gap: 6px;
|
|
padding: 10px;
|
|
background: #101416;
|
|
border: 1px solid #2c373a;
|
|
border-radius: 6px;
|
|
}
|
|
.hwlab-status-value, .hwlab-record-status, .hwlab-record-id, .hwlab-chain-value {
|
|
font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
|
|
}
|
|
.hwlab-chain-line {
|
|
grid-template-columns: minmax(0, 1fr) auto minmax(0, 1fr) auto minmax(0, 1fr);
|
|
align-items: center;
|
|
}
|
|
.hwlab-chain-node {
|
|
display: grid;
|
|
gap: 2px;
|
|
min-width: 0;
|
|
}
|
|
.hwlab-chain-value {
|
|
overflow-wrap: anywhere;
|
|
}
|
|
.hwlab-chain-arrow {
|
|
color: #95a6a3;
|
|
}
|
|
.hwlab-record-list, .hwlab-source-legend {
|
|
display: grid;
|
|
gap: 8px;
|
|
margin: 0;
|
|
padding: 0;
|
|
}
|
|
.hwlab-record-list {
|
|
list-style: none;
|
|
}
|
|
.hwlab-source-legend {
|
|
grid-template-columns: auto minmax(0, 1fr);
|
|
}
|
|
.hwlab-source-kind {
|
|
margin: 0;
|
|
font-weight: 700;
|
|
}
|
|
.hwlab-source-detail {
|
|
margin: 0;
|
|
}
|
|
.hwlab-control-list {
|
|
display: grid;
|
|
gap: 8px;
|
|
}
|
|
.hwlab-control-button {
|
|
min-width: 104px;
|
|
padding: 6px 9px;
|
|
color: #95a6a3;
|
|
background: #222a2d;
|
|
border: 1px solid #3a474b;
|
|
border-radius: 4px;
|
|
cursor: not-allowed;
|
|
}
|
|
.tone-blocked, .tone-degraded {
|
|
color: #ffb86b;
|
|
}
|
|
.tone-source, .tone-dry-run {
|
|
color: #8fc7ff;
|
|
}
|
|
.tone-trusted, .tone-dev-live, .tone-verified {
|
|
color: #74d99f;
|
|
}
|
|
`;
|
|
return style;
|
|
}
|