signalk-wiring 0.4.5 → 0.4.6

package/README.md

@@ -66,6 +66,10 @@ to someone else doesn't depend on the current owner being present.
   strip, and a red-shifted **night theme** that protects night vision,
   switched by a button or, with the `autoTheme` option, by the vessel's
   `environment.sun` or `environment.mode`.
+- **AC and DC aware**: mark devices AC or DC (new devices get it from their
+  type) and a new cable's type is chosen from its two ends, with a warning when
+  they disagree. A cable cannot carry both AC and DC, a conduit holding both
+  gets a warning, and AC cables are drawn dashed and DC solid.
 - **Schematics**: several named diagrams of the electrical system. Place
   devices (or create them from a palette by role), drag a wire from one to
   another and the cable and its circuit exist; wires are right-angled and
@@ -154,6 +158,9 @@ npm install
 npm test
 ```
 
+See [CONTRIBUTING.md](CONTRIBUTING.md) for how to report issues, plan larger
+changes and send pull requests.
+
 The webapp (`public/`) uses [Preact](https://preactjs.com/) and
 [`htm`](https://github.com/developit/htm) (JSX-like syntax without a
 build step) plus [`dagre`](https://github.com/dagrejs/dagre) for diagram

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalk-wiring",
-  "version": "0.4.5",
+  "version": "0.4.6",
   "description": "SignalK plugin for documenting a boat's physical electrical wiring: circuits, wire runs, and devices.",
   "main": "index.js",
   "files": [

package/public/app.js

@@ -22,7 +22,8 @@ import { deviceBox, endTerminals } from './schematic.js'
 import { PortBlocks } from './ports.js'
 import { useSettings, colorPlaceholder } from './settings.js'
 import { useTheme } from './theme.js'
-import { typeOptions, isCriticalType } from './deviceTypes.js'
+import { typeOptions, isCriticalType, typeCurrent } from './deviceTypes.js'
+import { suggestKind, mismatchText, conduitCurrentMix, conduitMixText } from './current.js'
 import { describeMeasured, describeGroup } from './measured.js'
 import { useLive } from './live.js'
 import { CalibrateDialog } from './calibrate.js'
@@ -59,13 +60,25 @@ async function fetchResource (type, id) {
   return res.json()
 }
 
+// A refused write (400) says why in its body, for example a cable that mixes
+// AC and DC; anything else keeps the generic text.
+async function refusalMessage (res, fallback) {
+  if (res.status !== 400 || typeof res.json !== 'function') return fallback
+  try {
+    const body = await res.json()
+    return body && typeof body.message === 'string' && body.message ? body.message : fallback
+  } catch (_) {
+    return fallback
+  }
+}
+
 async function putResource (type, id, value) {
   const res = await fetch(`${RESOURCE_BASE}/${type}/${id}`, {
     method: 'PUT',
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify(value)
   })
-  if (!res.ok) throw new Error(apiErrorMessage(res.status))
+  if (!res.ok) throw new Error(await refusalMessage(res, apiErrorMessage(res.status)))
 }
 
 // Undo of a removal: a plain write of status active, which the store logs as a restore.
@@ -406,7 +419,7 @@ function Form ({ fields, initial, onSubmit, onCancel, submitLabel = 'Save', cont
           `}
           ${f.type === 'select' && html`
             <select value=${values[f.key]} onChange=${(e) => setField(f.key, e.target.value)}>
-              ${!f.noBlank && html`<option value="">—</option>`}
+              ${!f.noBlank && html`<option value="">${f.blankLabel || '—'}</option>`}
               ${f.options.map((o) => {
                 const option = typeof o === 'string' ? { value: o, label: o } : o
                 return html`<option value=${option.value} key=${option.value}>${option.label}</option>`
@@ -667,6 +680,13 @@ function criticalDefault (key, value, values, touched) {
   return extra
 }
 
+// For a new device the Current select follows the type until the user sets it.
+function newDeviceDefaults (key, value, values, touched) {
+  const extra = criticalDefault(key, value, values, touched) || {}
+  if (key === 'type' && !touched.current) extra.current = typeCurrent(value) || ''
+  return extra
+}
+
 const DEVICE_FIELDS = [
   { key: 'name', label: 'Name', type: 'text', required: true },
   {
@@ -696,6 +716,15 @@ const DEVICE_FIELDS = [
     type: 'tags',
     hint: 'Anything else you want to group by, such as an audio zone. Free text, several allowed, separated by commas.'
   },
+  {
+    key: 'current',
+    label: 'Current',
+    type: 'select',
+    options: [{ value: 'ac', label: 'AC' }, { value: 'dc', label: 'DC' }],
+    blankLabel: 'Either',
+    clearable: true,
+    hint: 'Whether this device is AC or DC. Cables drawn to it get the matching cable type, and a warning appears when the two ends disagree. Starts from the type (a battery is DC, a shore power inlet AC). Leave it on Either for converters and for devices whose terminals say it already.'
+  },
   { key: 'ratedPowerW', label: 'Rated power (W)', type: 'number' },
   {
     key: 'tripRatingA',
@@ -1021,7 +1050,25 @@ function CableForm ({ cable, prefill, devices, cables, circuits, onDevicesChange
   const [more, setMore] = useState(() => (cable || prefill) ? kindByValue(values.kind).more : false)
   const [saving, setSaving] = useState(false)
   const [error, setError] = useState(null)
+  // Until the user picks a kind themselves, the kind follows the two ends. A
+  // cable being edited, or one that arrives with a kind chosen elsewhere
+  // (the quick popover), keeps its kind.
+  const [kindTouched, setKindTouched] = useState(Boolean(cable || (prefill && prefill.kind)))
   const set = (key, value) => setValues((v) => ({ ...v, [key]: value }))
+  const setKind = (kind) => { setKindTouched(true); set('kind', kind) }
+  const setEnd = (key, id) => {
+    const next = { ...values, [key]: id }
+    if (!kindTouched && !cable) {
+      const from = devices.find((d) => d.id === next.fromDeviceId)
+      const to = devices.find((d) => d.id === next.toDeviceId)
+      if (from && to) {
+        const { kind } = suggestKind(from, '', to, '')
+        if (kindByValue(kind).more) setMore(true)
+        next.kind = kind
+      }
+    }
+    setValues(next)
+  }
   const setColor = (conductor, value) => setValues((v) => ({ ...v, colors: { ...v.colors, [conductor]: value } }))
   const setTerminal = (conductor, end, value) => setValues((v) => ({
     ...v,
@@ -1035,6 +1082,7 @@ function CableForm ({ cable, prefill, devices, cables, circuits, onDevicesChange
     ? values.existingConductors.map((c) => c.conductor)
     : kindByValue(values.kind).conductors
   const askTerminals = needsTerminal(fromDevice) || needsTerminal(toDevice)
+  const mismatch = !cable && fromDevice && toDevice ? suggestKind(fromDevice, '', toDevice, '').mismatch : null
   const kinds = CABLE_KINDS.filter((k) => !k.more || more || k.value === values.kind)
 
   const submit = async (e) => {
@@ -1058,20 +1106,21 @@ function CableForm ({ cable, prefill, devices, cables, circuits, onDevicesChange
     <form class="inline-form cable-form" onSubmit=${submit}>
       <${ErrorBanner} message=${error} />
       <${DevicePicker} label="From (supply side)" required=${true} value=${values.fromDeviceId}
-        onChange=${(v) => set('fromDeviceId', v)} devices=${devices} onCreated=${onDevicesChanged}
+        onChange=${(v) => setEnd('fromDeviceId', v)} devices=${devices} onCreated=${onDevicesChanged}
         defaultRole="distribution"
         hint="The side the power comes from: a fuse, breaker, bus bar, battery or source." />
       <${DevicePicker} label="To (load side)" required=${true} value=${values.toDeviceId}
-        onChange=${(v) => set('toDeviceId', v)} devices=${devices} onCreated=${onDevicesChanged}
+        onChange=${(v) => setEnd('toDeviceId', v)} devices=${devices} onCreated=${onDevicesChanged}
         defaultRole="consumer" />
 
       <div class="form-field">
         <span>Conductors</span>
+        ${mismatch && html`<div class="warning-banner" data-testid="current-mismatch">${mismatchText(mismatch, fromDevice, toDevice)}</div>`}
         <div class="kind-choice">
           ${kinds.map((k) => html`
             <label key=${k.value} class="radio-chip">
               <input type="radio" name="cable-kind" value=${k.value} checked=${values.kind === k.value}
-                onChange=${() => set('kind', k.value)} />
+                onChange=${() => setKind(k.value)} />
               ${k.label}
             </label>
           `)}
@@ -1767,7 +1816,7 @@ function DevicesList ({ onSelect }) {
       ${showForm && html`
         <${Form}
           fields=${DEVICE_FIELDS}
-          onFieldChange=${criticalDefault}
+          onFieldChange=${newDeviceDefaults}
           onSubmit=${createDevice}
           onCancel=${() => setShowForm(false)}
           submitLabel="Create device"
@@ -1886,6 +1935,7 @@ function DeviceDetail ({ deviceId, onBack, onNotFound = () => {} }) {
               <ul>${device.terminals.map((t, i) => html`<li key=${i}>${describeTerminal(t)}</li>`)}</ul>
             </div>
           `}
+          ${device.current && html`<div class="meta">Current: ${device.current === 'ac' ? 'AC' : 'DC'}</div>`}
           ${device.signalkPath && html`
             <div class="meta">SignalK path: <code>${device.signalkPath}</code></div>
           `}
@@ -1949,6 +1999,9 @@ function ConduitsList ({ onSelect }) {
   const [reloadKey, setReloadKey] = useState(0)
   const [showForm, setShowForm] = useState(false)
   const { loading, error, items } = useResourceList('wiringConduits', reloadKey)
+  const { items: allRuns } = useResourceList('wiringWireRuns', reloadKey)
+  const runById = new Map(allRuns.map((r) => [r.id, r]))
+  const mixesOf = (conduit) => conduitCurrentMix((conduit.cableIds || []).map((id) => runById.get(id)).filter(Boolean)).mixed
   const [filter, setFilter] = useState({})
   const { suggested, used } = kindOptions(items.map((c) => c.kind), '')
   const visible = filterConduits(items, filter)
@@ -2000,6 +2053,7 @@ function ConduitsList ({ onSelect }) {
           <div>
             <div>${conduit.name}</div>
             <div class="meta">${conduitSummary(conduit)}${conduit.zone ? ` – ${conduit.zone}` : ''} – ${(conduit.cableIds || []).length === 1 ? '1 cable' : `${(conduit.cableIds || []).length} cables`}</div>
+            ${mixesOf(conduit) && html`<div class="meta" style="color: var(--warn)" data-testid="conduit-mix-line">Mixes AC and DC</div>`}
           </div>
           <${StatusBadge} status=${conduit.status} />
         </div>
@@ -2016,6 +2070,7 @@ function ConduitDetail ({ conduitId, onBack, onNotFound = () => {} }) {
   const [editing, setEditing] = useState(false)
   const [showHistory, setShowHistory] = useState(false)
   const [toAdd, setToAdd] = useState('')
+  const [mixNotice, setMixNotice] = useState(null)
   const { items: runs } = useResourceList('wiringWireRuns', reloadKey)
   const { items: devices } = useResourceList('wiringDevices')
   const { items: conduits } = useResourceList('wiringConduits', reloadKey)
@@ -2048,12 +2103,17 @@ function ConduitDetail ({ conduitId, onBack, onNotFound = () => {} }) {
     onBack() // leaving the page first: it would otherwise finish the message below
     undo.offer({ message: `Conduit "${name}" removed.`, onUndo: () => restoreResource('wiringConduits', conduitId) })
   }
-  const setCables = (cableIds) => guard(() => putResource('wiringConduits', conduitId, { cableIds }))
+  const setCables = (cableIds) => { setMixNotice(null); return guard(() => putResource('wiringConduits', conduitId, { cableIds })) }
   const addCable = () => {
     if (!toAdd) return
     const id = toAdd
     setToAdd('')
-    return setCables([...(conduit.cableIds || []), id])
+    const cableIds = [...(conduit.cableIds || []), id]
+    const mix = conduitCurrentMix(cableIds.map((cid) => runById.get(cid)).filter(Boolean))
+    // Never blocks: the cable is added, and the warning is shown after.
+    const done = setCables(cableIds)
+    setMixNotice(mix.mixed ? conduitMixText(mix, (r) => cableName(r, deviceNameById)) : null)
+    return done
   }
   // Moves this conduit one place earlier or later in the cable's own list.
   const moveForCable = (run, delta) =>
@@ -2061,6 +2121,7 @@ function ConduitDetail ({ conduitId, onBack, onNotFound = () => {} }) {
 
   const cables = conduit ? (conduit.cableIds || []).map((id) => runById.get(id)).filter(Boolean) : []
   const candidates = conduit ? addableCables(runs, conduit) : []
+  const mixText = conduitMixText(conduitCurrentMix(cables), (r) => cableName(r, deviceNameById))
 
   return html`
     <div>
@@ -2094,7 +2155,9 @@ function ConduitDetail ({ conduitId, onBack, onNotFound = () => {} }) {
         </div>
       `}
       ${showHistory && html`<${ChangeLog} kind="conduit" id=${conduitId} />`}
+      ${mixNotice && html`<div class="warning-banner" style="white-space: pre-line" data-testid="conduit-mix-notice"><strong>Added, but check this:</strong> ${mixNotice}</div>`}
       ${conduit && html`
+        ${mixText && !mixNotice && html`<div class="warning-banner" style="white-space: pre-line" data-testid="conduit-mix-warning">${mixText}</div>`}
         <h3>Cables in this conduit (${cables.length})</h3>
         ${cables.length === 0 && html`<div class="empty-state">No cables assigned yet.</div>`}
         ${cables.map((run) => {

package/public/cablePopover.js

@@ -1,5 +1,6 @@
 import { html, useState } from './vendor/preact-standalone.module.js'
 import { CABLE_KINDS, buildCablePayload } from './cableForm.js'
+import { mismatchText } from './current.js'
 import { popoverKinds, quickProblem, withKind } from './quickCable.js'
 
 // The small popover that asks how a freshly drawn wire is made: Positive,
@@ -14,7 +15,7 @@ export function CablePopover ({ start, lengthNote, style, onCreate, onMore, onCa
   const [saving, setSaving] = useState(false)
   const [error, setError] = useState(null)
   const set = (key, value) => setValues((v) => ({ ...v, [key]: value }))
-  const kinds = popoverKinds(start.values.kind, CABLE_KINDS)
+  const kinds = popoverKinds(start.values.kind, CABLE_KINDS, start.mismatch)
 
   const create = async () => {
     const problem = quickProblem(start, values)
@@ -33,6 +34,7 @@ export function CablePopover ({ start, lengthNote, style, onCreate, onMore, onCa
     <div class="cable-popover" style=${style} data-testid="cable-popover"
       onPointerDown=${(e) => e.stopPropagation()}>
       <div class="cable-popover-title">${start.from.name} to ${start.to.name}</div>
+      ${start.mismatch && html`<div class="warning-banner" data-testid="current-mismatch">${mismatchText(start.mismatch, start.from, start.to)}</div>`}
       <div class="cable-popover-kinds">
         ${kinds.map((k) => html`
           <label key=${k.value} class="radio-line">

package/public/current.js

@@ -0,0 +1,113 @@
+// AC and DC awareness (plan 0019): which current each end of a cable carries
+// and which cable type that suggests. Pure. The server has the type table and
+// mixesAcAndDc in src/current.js; tests keep both in step.
+
+import { defaultKind } from './schematic.js'
+
+// 'ac' for line, neutral and earth, 'dc' for positive and negative, null for
+// signal or anything else.
+export function conductorCurrent (conductorType) {
+  if (conductorType === 'line' || conductorType === 'neutral' || conductorType === 'earth') return 'ac'
+  if (conductorType === 'positive' || conductorType === 'negative') return 'dc'
+  return null
+}
+
+// The current a device's terminals agree on: all AC or all DC. Mixed, signal
+// only or none is unknown.
+function terminalsCurrent (device) {
+  const terminals = device.terminals || []
+  if (terminals.length === 0) return null
+  const set = new Set(terminals.map((t) => conductorCurrent(t.conductor)))
+  return set.size === 1 && !set.has(null) ? [...set][0] : null
+}
+
+// The current at one end of a cable: the terminal dropped on decides, else
+// the device mark, else what all its terminals agree on, else null.
+export function endCurrent (device, terminalName) {
+  if (!device) return null
+  if (terminalName) {
+    const terminal = (device.terminals || []).find((t) => t.name === terminalName)
+    if (terminal) {
+      if (terminal.conductor === 'signal') return null
+      const fromTerminal = conductorCurrent(terminal.conductor)
+      if (fromTerminal) return fromTerminal
+    }
+  }
+  if (device.current === 'ac' || device.current === 'dc') return device.current
+  return terminalsCurrent(device)
+}
+
+// The cable type to start with for a new cable From a device (the supply end)
+// To another. `mismatch` is null, or { fromCurrent, toCurrent } when both ends
+// are known and differ; the kind then follows the From end.
+export function suggestKind (from, fromTerminal, to, toTerminal) {
+  const terminals = [...(from.terminals || []), ...(to.terminals || [])]
+  if (terminals.length > 0 && terminals.every((t) => t.conductor === 'signal')) {
+    return { kind: 'signal', mismatch: null }
+  }
+  const fromCurrent = endCurrent(from, fromTerminal)
+  const toCurrent = endCurrent(to, toTerminal)
+  if (!fromCurrent && !toCurrent) return { kind: defaultKind(from, to), mismatch: null }
+  const current = fromCurrent || toCurrent
+  const mismatch = fromCurrent && toCurrent && fromCurrent !== toCurrent ? { fromCurrent, toCurrent } : null
+  if (current === 'ac') return { kind: 'ac', mismatch }
+  const lone = from.role === 'distribution' || to.role === 'distribution'
+  return { kind: lone ? 'positive' : 'both', mismatch }
+}
+
+// True when the conductors (objects with a `conductor`, or plain type names)
+// include a line or neutral one and a positive or negative one. Earth and
+// signal never count.
+export function mixesAcAndDc (conductors) {
+  const types = (Array.isArray(conductors) ? conductors : []).map((c) => (c && c.conductor) || c)
+  return types.some((t) => t === 'line' || t === 'neutral') &&
+    types.some((t) => t === 'positive' || t === 'negative')
+}
+
+// 'ac' when the cable has a line or neutral conductor, 'dc' when it has a
+// positive or negative one, null otherwise. A cable with no conductors listed
+// is a single positive, so dc.
+export function cableCurrent (cable) {
+  const types = ((cable && cable.conductors) || []).map((c) => c.conductor)
+  if (types.length === 0) return 'dc'
+  if (types.some((t) => t === 'line' || t === 'neutral')) return 'ac'
+  if (types.some((t) => t === 'positive' || t === 'negative')) return 'dc'
+  return null
+}
+
+// The warning shown above the kind choice when the two ends disagree, using
+// the device names. Null when there is no mismatch.
+export function mismatchText (mismatch, from, to) {
+  if (!mismatch) return null
+  const label = (c) => (c === 'ac' ? 'AC' : 'DC')
+  return `${from.name} is ${label(mismatch.fromCurrent)}, ${to.name} is ${label(mismatch.toCurrent)}. Choose the cable type.`
+}
+
+// The live (not removed) cables of a conduit sorted by current: `ac` and `dc`
+// hold the cables, `mixed` is true only when both are non-empty. Cables that
+// are neither (signal only, earth only) count as neither.
+export function conduitCurrentMix (cables) {
+  const ac = []
+  const dc = []
+  for (const cable of cables || []) {
+    if (!cable || cable.status === 'removed') continue
+    const current = cableCurrent(cable)
+    if (current === 'ac') ac.push(cable)
+    else if (current === 'dc') dc.push(cable)
+  }
+  return { ac, dc, mixed: ac.length > 0 && dc.length > 0 }
+}
+
+// The warning for a mixed conduit: a heading, the advice and the cables named
+// under AC and under DC, as lines joined with newlines. Null when not mixed.
+// `cableName` turns a cable into the name shown.
+export function conduitMixText (mix, cableName) {
+  if (!mix || !mix.mixed) return null
+  const names = (list) => list.map((c) => cableName(c)).join(', ')
+  return [
+    'This conduit holds AC and DC cables.',
+    'Keep them in separate conduits where you can. If they share one, the AC must be in its own sheathed cable, all insulation rated for the highest voltage present, and ideally a partition.',
+    `AC: ${names(mix.ac)}`,
+    `DC: ${names(mix.dc)}`
+  ].join('\n')
+}

package/public/deviceTypes.js

@@ -54,3 +54,23 @@ export function isCriticalType (type) {
   const text = type.trim().toLowerCase()
   return text !== '' && CRITICAL_TYPE_WORDS.some((word) => text.includes(word))
 }
+
+// Device types that are plainly AC or DC (plan 0019), matched ignoring case on
+// the whole type name. Converters, distribution devices and consumers are not
+// listed: their ports or the supply side decide. The same table is in
+// src/current.js (the store applies it too); a test keeps both equal.
+export const AC_TYPES = ['Shore power inlet', 'Generator', 'Isolation transformer']
+export const DC_TYPES = [
+  'Solar panel', 'Alternator', 'Wind generator', 'Hydro generator', 'Fuel cell',
+  'Battery', 'Battery bank', 'Lead-acid battery', 'AGM battery', 'LiFePO4 battery',
+  'Starter battery', 'House battery', 'Shunt', 'Battery isolator', 'Battery switch'
+]
+
+// 'ac', 'dc' or null for a type name.
+export function typeCurrent (type) {
+  if (typeof type !== 'string') return null
+  const text = type.trim().toLowerCase()
+  if (AC_TYPES.some((t) => t.toLowerCase() === text)) return 'ac'
+  if (DC_TYPES.some((t) => t.toLowerCase() === text)) return 'dc'
+  return null
+}

package/public/floorplanView.js

@@ -9,7 +9,7 @@ import {
   escapeStep, deleteStep
 } from './floorplan.js'
 import { hashForState } from './router.js'
-import { isTypingTarget } from './schematic.js'
+import { isTypingTarget, wireLineStyle, scaledDash } from './schematic.js'
 import { useUndo } from './undoBar.js'
 import { offerCableUndo } from './canvasRemoval.js'
 import { cableName } from './conduits.js'
@@ -41,13 +41,25 @@ async function fetchList (type) {
   return Object.values(await res.json())
 }
 
+// A refused write (400) says why in its body, for example a cable that mixes
+// AC and DC; anything else keeps the generic text.
+async function refusalMessage (res, fallback) {
+  if (res.status !== 400 || typeof res.json !== 'function') return fallback
+  try {
+    const body = await res.json()
+    return body && typeof body.message === 'string' && body.message ? body.message : fallback
+  } catch (_) {
+    return fallback
+  }
+}
+
 async function putResource (type, id, value) {
   const res = await fetch(`${RESOURCE_BASE}/${type}/${id}`, {
     method: 'PUT',
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify(value)
   })
-  if (!res.ok) throw new Error(failureMessage(res.status))
+  if (!res.ok) throw new Error(await refusalMessage(res, failureMessage(res.status)))
 }
 
 async function deleteResource (type, id) {
@@ -394,7 +406,7 @@ function PlanViewer ({ plan, data, ctx, actions, onSaved, onError }) {
         return ownRoute && key >= 0 && isActive ? pxFor('waypoint', key, p) : (planShowsPoint(plan, p) ? pointToPx(cal, plan.view, p) : null)
       })
       for (const seg of visibleSegments(pxs)) {
-        runLines.push({ id: run.id, active: isActive, highlighted: inCircuit, points: seg.map((p) => p.join(',')).join(' ') })
+        runLines.push({ id: run.id, dash: wireLineStyle(run).dasharray, active: isActive, highlighted: inCircuit, points: seg.map((p) => p.join(',')).join(' ') })
       }
       addContinuations(run.id, points)
       if (isActive && ownRoute) {
@@ -497,7 +509,8 @@ function PlanViewer ({ plan, data, ctx, actions, onSaved, onError }) {
         ${runLines.map((l, i) => html`
           <polyline key=${l.id + ':' + i} points=${l.points} fill="none"
             class="run-line ${l.active ? 'active' : ''} ${l.highlighted ? 'highlighted' : ''}"
-            stroke-width=${unit * (l.active ? 0.9 : 0.5)} />
+            stroke-width=${unit * (l.active ? 0.9 : 0.5)}
+            stroke-dasharray=${scaledDash(l.dash, unit * (l.active ? 0.9 : 0.5) / 3) || undefined} />
         `)}
 
         ${connectLines.map((points, i) => html`

package/public/import.js

@@ -352,9 +352,16 @@ async function putResource (type, id, value) {
     body: JSON.stringify(value)
   })
   if (!res.ok) {
-    const message = res.status === 401
+    let message = res.status === 401
       ? 'You need to be logged into the SignalK admin UI to do this.'
       : `Import failed (server responded ${res.status}).`
+    // A refused write says why (for example a cable that mixes AC and DC).
+    if (res.status === 400 && typeof res.json === 'function') {
+      try {
+        const body = await res.json()
+        if (body && typeof body.message === 'string' && body.message) message = body.message
+      } catch (_) { /* keep the generic message */ }
+    }
     throw new Error(message)
   }
 }
@@ -399,24 +406,34 @@ export async function importToStore (grouped) {
     devicesCreated++
   }
 
+  // A cable the store refuses (it mixes AC and DC, say) is reported as an
+  // error row and does not stop the others.
   const cableIdByTempId = new Map()
+  const rowErrors = []
+  const deviceName = (tempId) => (grouped.devices.find((d) => d.tempId === tempId) || {}).name || '?'
   for (const wr of grouped.wireRuns) {
     const id = newId()
-    await putResource('wiringWireRuns', id, {
-      fromDeviceId: deviceIdByTempId.get(wr.fromTempId),
-      toDeviceId: deviceIdByTempId.get(wr.toTempId),
-      conductors: [{ conductor: wr.conductor || 'positive', color: wr.color || undefined }],
-      gauge: wr.gauge ?? undefined,
-      gaugeUnit: wr.gaugeUnit || undefined,
-      length: wr.length ?? undefined,
-      lengthUnit: wr.lengthUnit || undefined,
-      zone: wr.zone || undefined,
-      cableLabel: wr.cableLabel || undefined,
-      switchRef: wr.switchRef || undefined,
-      conduitIds: (wr.conduitTempIds || []).length > 0
-        ? wr.conduitTempIds.map((t) => conduitIdByTempId.get(t))
-        : undefined
-    })
+    try {
+      await putResource('wiringWireRuns', id, {
+        fromDeviceId: deviceIdByTempId.get(wr.fromTempId),
+        toDeviceId: deviceIdByTempId.get(wr.toTempId),
+        conductors: [{ conductor: wr.conductor || 'positive', color: wr.color || undefined }],
+        gauge: wr.gauge ?? undefined,
+        gaugeUnit: wr.gaugeUnit || undefined,
+        length: wr.length ?? undefined,
+        lengthUnit: wr.lengthUnit || undefined,
+        zone: wr.zone || undefined,
+        cableLabel: wr.cableLabel || undefined,
+        switchRef: wr.switchRef || undefined,
+        conduitIds: (wr.conduitTempIds || []).length > 0
+          ? wr.conduitTempIds.map((t) => conduitIdByTempId.get(t))
+          : undefined
+      })
+    } catch (err) {
+      if (/logged into/.test(err.message)) throw err
+      rowErrors.push({ cable: `${deviceName(wr.fromTempId)} to ${deviceName(wr.toTempId)}`, message: err.message })
+      continue
+    }
     cableIdByTempId.set(wr.tempId, id)
   }
 
@@ -425,7 +442,8 @@ export async function importToStore (grouped) {
   return {
     devicesCreated,
     devicesMatched: grouped.devices.length - devicesCreated,
-    wireRunsCreated: grouped.wireRuns.length,
+    wireRunsCreated: cableIdByTempId.size,
+    rowErrors,
     unconnectedRows: grouped.unconnectedRows || 0,
     circuitsNamed,
     conduitsCreated
@@ -618,6 +636,12 @@ export function CsvImport ({ onDone, onCancel }) {
             Imported ${result.devicesCreated} new device(s) (${result.devicesMatched} matched by name)
             and ${result.wireRunsCreated} cable(s)${result.circuitsNamed > 0 ? `; ${result.circuitsNamed} circuit(s) named from the circuit column` : ''}${result.conduitsCreated > 0 ? `, plus ${result.conduitsCreated} new conduit(s)` : ''}.
           </p>
+          ${(result.rowErrors || []).length > 0 && html`
+            <div class="error-banner" data-testid="import-row-errors">
+              ${result.rowErrors.length} cable(s) were not imported:
+              <ul>${result.rowErrors.map((e, i) => html`<li key=${i}>${e.cable}: ${e.message}</li>`)}</ul>
+            </div>
+          `}
           <div class="form-actions">
             <button type="button" onClick=${onDone}>Done</button>
           </div>

package/public/quickCable.js

@@ -4,12 +4,14 @@
 // buildCablePayload, so validation and circuit derivation are shared.
 
 import { kindByValue, defaultNegativeLanding, needsTerminal, terminalOptions, validateCable } from './cableForm.js'
-import { supplyOrder, defaultKind } from './schematic.js'
+import { supplyOrder } from './schematic.js'
+import { suggestKind } from './current.js'
 
 // The kinds the popover offers: the three DC ones, plus the suggested kind
 // when it is an AC or earth one.
-export function popoverKinds (suggested, allKinds) {
-  return allKinds.filter((k) => !k.more || k.value === suggested)
+// With a mismatch the plain AC kind is offered too, so either side can be chosen.
+export function popoverKinds (suggested, allKinds, mismatch = null) {
+  return allKinds.filter((k) => !k.more || k.value === suggested || (mismatch && k.value === 'ac'))
 }
 
 // For each conductor of the kind, the terminal to use at each end: the one
@@ -54,12 +56,13 @@ export function startValues ({ a, ta, b, tb, cables, defaults = {}, keepOrder =
   const swapped = from.id !== a.id
   const fromTerminal = swapped ? tb : ta
   const toTerminal = swapped ? ta : tb
-  const kind = defaultKind(from, to)
+  const { kind, mismatch } = suggestKind(from, fromTerminal, to, toTerminal)
   return {
     from,
     to,
     fromTerminal: fromTerminal || '',
     toTerminal: toTerminal || '',
+    mismatch,
     values: {
       fromDeviceId: from.id,
       toDeviceId: to.id,

package/public/schematic.js

@@ -1,3 +1,4 @@
+import { cableCurrent } from './current.js'
 // Pure geometry for the schematic canvas (plan 0016): device boxes and their
 // terminal anchors, right-angle wire routing with lane offsets, wires through
 // bend points, off-page stubs, hit testing, default conductors and the
@@ -544,6 +545,51 @@ export function conductorTypes (cable) {
   return types.length ? types : ['positive']
 }
 
+// The long-dash pattern that marks AC cables, shared by the schematic and the
+// floorplan (the floorplan scales it to its line width).
+export const AC_DASH = [10, 6]
+
+// How a cable's current shows: `current` is 'ac', 'dc' or null, `dasharray` a
+// stroke-dasharray string (AC only, DC and the rest stay solid) and `marker`
+// the midpoint symbol on the schematic ('ac' tilde, 'dc' symbol, null).
+export function wireLineStyle (cable) {
+  const current = cableCurrent(cable)
+  return {
+    current,
+    dasharray: current === 'ac' ? AC_DASH.join(' ') : null,
+    marker: current
+  }
+}
+
+// The same dash pattern scaled by a factor, as a stroke-dasharray string.
+export function scaledDash (dasharray, factor) {
+  if (!dasharray) return null
+  return dasharray.split(' ').map((n) => Math.round(Number(n) * factor * 100) / 100).join(' ')
+}
+
+// A copy of a polyline moved sideways by `dist` (positive is to the right of
+// the direction of travel), corners mitred, for drawing the second conductor
+// of a cable beside the first.
+export function offsetPath (points, dist) {
+  if (points.length < 2) return points.map((p) => ({ ...p }))
+  const normals = []
+  for (let i = 1; i < points.length; i++) {
+    const dx = points[i].x - points[i - 1].x
+    const dy = points[i].y - points[i - 1].y
+    const len = Math.hypot(dx, dy)
+    normals.push(len > 0 ? { x: -dy / len, y: dx / len } : null)
+  }
+  const fallback = normals.find(Boolean) || { x: 0, y: 0 }
+  const at = (i) => normals[i] || normals[i - 1] || fallback
+  return points.map((p, i) => {
+    const a = i === 0 ? at(0) : at(i - 1)
+    const b = i === points.length - 1 ? a : at(i)
+    const dot = a.x * b.x + a.y * b.y
+    const k = dist / Math.max(1 + dot, 0.2)
+    return { x: p.x + (a.x + b.x) * k, y: p.y + (a.y + b.y) * k }
+  })
+}
+
 // ---- Highlighting -----------------------------------------------------------
 
 // The devices and cables a circuit resource spans, for highlighting.

package/public/schematicView.js

@@ -32,13 +32,25 @@ function failureMessage (status) {
   return `Request failed (server responded ${status}).`
 }
 
+// A refused write (400) says why in its body, for example a cable that mixes
+// AC and DC; anything else keeps the generic text.
+async function refusalMessage (res, fallback) {
+  if (res.status !== 400 || typeof res.json !== 'function') return fallback
+  try {
+    const body = await res.json()
+    return body && typeof body.message === 'string' && body.message ? body.message : fallback
+  } catch (_) {
+    return fallback
+  }
+}
+
 async function putResource (type, id, value) {
   const res = await fetch(`${RESOURCE_BASE}/${type}/${id}`, {
     method: 'PUT',
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify(value)
   })
-  if (!res.ok) throw new Error(failureMessage(res.status))
+  if (!res.ok) throw new Error(await refusalMessage(res, failureMessage(res.status)))
 }
 
 async function deleteResource (type, id) {
@@ -653,6 +665,7 @@ function SchematicEditor ({ schematic, data, reload, onBack, onOpen, onError, re
           ${pageCircuits.map((c) => html`<option value=${c.id} key=${c.id}>${c.name}</option>`)}
         </select>
       </div>
+      <div class="meta schematic-legend" data-testid="schematic-legend">Solid lines are DC, dashed lines are AC. A thin line beside a wire is its second conductor.</div>
       ${liveOn && html`<${LiveBar} live=${live} error=${live.error} />`}
       ${notice && html`<div class="meta schematic-notice" data-testid="notice">${notice}</div>`}
       ${moreForm && html`
@@ -768,14 +781,32 @@ function cableLine (cable, deviceName) {
   return parts.join(', ')
 }
 
+// The standard marker: a tilde for AC, the DC symbol (a solid line over a
+// dashed one, IEC 60617) for DC, on a small pad so it stays readable.
+function WireMarker ({ kind, at }) {
+  return html`
+    <g class="sch-wire-marker" transform="translate(${at.x} ${at.y})" data-marker=${kind}>
+      <rect x="-9" y="-7" width="18" height="14" rx="3" class="sch-marker-pad" />
+      ${kind === 'ac'
+        ? html`<path d="M-5 0 Q-2.5 -5 0 0 T5 0" class="sch-marker-stroke" />`
+        : html`
+          <line x1="-5" y1="-2" x2="5" y2="-2" class="sch-marker-stroke" />
+          <line x1="-5" y1="2" x2="5" y2="2" class="sch-marker-stroke" stroke-dasharray="2 1.5" />`}
+    </g>
+  `
+}
+
 function WireShape ({ wire, deviceName, selected, dim, lit }) {
   const types = G.conductorTypes(wire.cable)
+  const style = G.wireLineStyle(wire.cable)
   const d = G.pathToD(wire.path)
+  const paired = types.length > 1 ? G.pathToD(G.offsetPath(wire.path, 4)) : null
   const cls = `sch-wire${selected ? ' selected' : ''}${dim ? ' dim' : ''}${lit ? ' lit' : ''}`
   return html`
-    <g class=${cls} data-wire=${wire.id}>
-      <path d=${d} class="sch-wire-line c-${types[0]}"><title>${cableLine(wire.cable, deviceName)}</title></path>
-      ${types.length > 1 && html`<path d=${d} class="sch-wire-over c-${types[1]}" />`}
+    <g class=${cls} data-wire=${wire.id} data-current=${style.current || ''}>
+      <path d=${d} class="sch-wire-line c-${types[0]}" stroke-dasharray=${style.dasharray || undefined}><title>${cableLine(wire.cable, deviceName)}</title></path>
+      ${paired && html`<path d=${paired} class="sch-wire-pair c-${types[1]}" stroke-dasharray=${style.dasharray || undefined} />`}
+      ${style.marker && html`<${WireMarker} kind=${style.marker} at=${G.pathMidpoint(wire.path)} />`}
     </g>
   `
 }

package/public/style.css

@@ -219,6 +219,16 @@ th { color: var(--text-muted-strong); font-weight: 600; background: var(--surfac
   font-size: 13px;
 }
 
+.warning-banner {
+  background: var(--warn-bg);
+  border: 1px solid var(--warn);
+  color: var(--warn);
+  padding: 8px 12px;
+  border-radius: 8px;
+  margin-bottom: 10px;
+  font-size: 13px;
+}
+
 button {
   font: inherit;
   font-size: 13px;
@@ -647,20 +657,26 @@ main:has(.floorplan-pair) { max-width: none; }
 .sch-terminal.c-neutral { fill: var(--wire-neutral); }
 .sch-terminal.c-earth { fill: var(--wire-earth); }
 
-.sch-wire-line, .sch-wire-over, .sch-stub-line { fill: none; stroke-width: 3; stroke-linejoin: round; }
+.sch-wire-line, .sch-wire-pair, .sch-stub-line { fill: none; stroke-width: 3; stroke-linejoin: round; }
 .sch-wire-line.c-positive { stroke: var(--wire-positive); }
 .sch-wire-line.c-negative { stroke: var(--wire-negative); }
 .sch-wire-line.c-line { stroke: var(--wire-line); }
 .sch-wire-line.c-neutral { stroke: var(--wire-neutral); }
 .sch-wire-line.c-earth { stroke: var(--wire-earth); }
 .sch-wire-line.c-signal { stroke: var(--wire-signal); }
-.sch-wire-over { stroke-dasharray: 6 6; }
-.sch-wire-over.c-positive { stroke: var(--wire-positive); }
-.sch-wire-over.c-negative { stroke: var(--wire-negative); }
-.sch-wire-over.c-line { stroke: var(--wire-line); }
-.sch-wire-over.c-neutral { stroke: var(--wire-neutral); }
-.sch-wire-over.c-earth { stroke: var(--wire-earth); }
+.sch-wire-pair { stroke-width: 1.5; }
+.sch-wire-pair.c-positive { stroke: var(--wire-positive); }
+.sch-wire-pair.c-negative { stroke: var(--wire-negative); }
+.sch-wire-pair.c-line { stroke: var(--wire-line); }
+.sch-wire-pair.c-neutral { stroke: var(--wire-neutral); }
+.sch-wire-pair.c-earth { stroke: var(--wire-earth); }
+.sch-wire-pair.c-signal { stroke: var(--wire-signal); }
+.sch-marker-pad { fill: var(--surface); fill-opacity: 0.9; stroke: none; }
+.sch-marker-stroke { fill: none; stroke: var(--text-muted-strong); stroke-width: 1.4; stroke-linecap: round; }
+.sch-wire-marker { pointer-events: none; }
+.schematic-legend { margin: 2px 0 6px; }
 .sch-wire.selected .sch-wire-line { stroke-width: 5; }
+.sch-wire.selected .sch-wire-pair, .sch-wire.lit .sch-wire-pair { stroke-width: 2.5; }
 .sch-wire.dim { opacity: 0.2; }
 .sch-wire.lit .sch-wire-line { stroke-width: 5; }
 .sch-stub-line { stroke: var(--text-muted-strong); stroke-dasharray: 4 3; stroke-width: 2; }

package/src/current.js

@@ -0,0 +1,52 @@
+'use strict'
+
+// AC and DC awareness (plan 0019), the parts the server needs. The browser has
+// the same table and rule in public/current.js and public/deviceTypes.js;
+// test/current.test.mjs and test/current.test.js keep both equal.
+
+const CURRENTS = ['ac', 'dc']
+
+// Device types that are plainly AC or DC, matched case-insensitively on the
+// whole type name. Everything else (converters, distribution, consumers) is
+// left unset.
+const AC_TYPES = ['Shore power inlet', 'Generator', 'Isolation transformer']
+const DC_TYPES = [
+  'Solar panel', 'Alternator', 'Wind generator', 'Hydro generator', 'Fuel cell',
+  'Battery', 'Battery bank', 'Lead-acid battery', 'AGM battery', 'LiFePO4 battery',
+  'Starter battery', 'House battery', 'Shunt', 'Battery isolator', 'Battery switch'
+]
+
+const TYPE_CURRENT = new Map([
+  ...AC_TYPES.map((t) => [t.toLowerCase(), 'ac']),
+  ...DC_TYPES.map((t) => [t.toLowerCase(), 'dc'])
+])
+
+// 'ac', 'dc' or null for a device type name.
+function typeCurrent (type) {
+  if (typeof type !== 'string') return null
+  return TYPE_CURRENT.get(type.trim().toLowerCase()) || null
+}
+
+const AC_CONDUCTORS = ['line', 'neutral', 'earth']
+const DC_CONDUCTORS = ['positive', 'negative']
+
+// The current a terminal list agrees on: all positive/negative is dc, all
+// line/neutral/earth is ac, anything mixed or empty is null.
+function terminalsCurrent (terminals) {
+  const list = Array.isArray(terminals) ? terminals : []
+  if (list.length === 0) return null
+  if (list.every((t) => DC_CONDUCTORS.includes(t.conductor))) return 'dc'
+  if (list.every((t) => AC_CONDUCTORS.includes(t.conductor))) return 'ac'
+  return null
+}
+
+// True when a cable's conductors include a line or neutral one and a positive
+// or negative one. Earth and signal never count. Takes conductor objects or
+// plain type names.
+function mixesAcAndDc (conductors) {
+  const types = (Array.isArray(conductors) ? conductors : []).map((c) => (c && c.conductor) || c)
+  return types.some((t) => t === 'line' || t === 'neutral') &&
+    types.some((t) => t === 'positive' || t === 'negative')
+}
+
+module.exports = { CURRENTS, AC_TYPES, DC_TYPES, typeCurrent, terminalsCurrent, mixesAcAndDc }

package/src/resources.js

@@ -20,6 +20,8 @@ function rowToResource (row) {
   if (!row) return row
   const out = {}
   for (const [k, v] of Object.entries(row)) {
+    // An unset current is absent, not null (plan 0019).
+    if (k === 'current' && (v === null || v === undefined)) continue
     out[toCamelKey(k)] = JSON_COLUMNS.has(k) && typeof v === 'string'
       ? JSON.parse(v)
       : BOOLEAN_COLUMNS.has(k) && v !== null && v !== undefined ? Boolean(v) : v

package/src/schema.sql

@@ -66,6 +66,7 @@ CREATE TABLE IF NOT EXISTS devices (
   trip_rating_a REAL,
   nominal_voltage REAL,
   power_factor REAL,
+  current TEXT,
   switch_path TEXT,
   confirm_switching INTEGER NOT NULL DEFAULT 0,
   never_remote INTEGER NOT NULL DEFAULT 0,

package/src/store.js

@@ -6,6 +6,7 @@ const crypto = require('crypto')
 const Database = require('better-sqlite3')
 const { deriveCircuits } = require('./circuits')
 const { isCriticalType } = require('./safety')
+const { CURRENTS, typeCurrent, terminalsCurrent, mixesAcAndDc } = require('./current')
 const { deriveSwitchability } = require('./switchability')
 
 const SCHEMA_SQL = fs.readFileSync(path.join(__dirname, 'schema.sql'), 'utf8')
@@ -27,7 +28,7 @@ const TABLES = {
     table: 'devices',
     columns: [
       'id', 'name', 'type', 'role', 'icon_attachment_id', 'zone', 'rated_power_w', 'signalk_path',
-      'trip_rating_a', 'nominal_voltage', 'power_factor', 'switch_path', 'confirm_switching', 'never_remote',
+      'trip_rating_a', 'nominal_voltage', 'power_factor', 'current', 'switch_path', 'confirm_switching', 'never_remote',
       'meter_path', 'meter_unit', 'pos_x', 'pos_y', 'pos_z', 'zone_id', 'tags', 'status', 'notes'
     ]
   },
@@ -372,6 +373,21 @@ const MIGRATIONS = [
         avg_w REAL, peak_w REAL, duty_cycle REAL, confidence TEXT, error TEXT)`)
       db.exec('CREATE INDEX IF NOT EXISTS idx_calibration_runs_device ON calibration_runs (device_id)')
     }
+  },
+  {
+    version: 10,
+    description: 'plan 0019: devices + current (ac, dc or null), filled once from the type and terminals',
+    apply (db) {
+      const hasColumn = db.prepare('PRAGMA table_info(devices)').all().some((c) => c.name === 'current')
+      if (!hasColumn) db.exec('ALTER TABLE devices ADD COLUMN current TEXT')
+      // The one-time fill: only where nothing is set, never over a mark.
+      const terminals = db.prepare('SELECT conductor FROM device_terminals WHERE device_id = ?')
+      const set = db.prepare('UPDATE devices SET current = ? WHERE id = ? AND current IS NULL')
+      for (const d of db.prepare('SELECT id, type FROM devices WHERE current IS NULL').all()) {
+        const value = typeCurrent(d.type) || terminalsCurrent(terminals.all(d.id))
+        if (value) set.run(value, d.id)
+      }
+    }
   }
 ]
 
@@ -698,7 +714,9 @@ class Store {
   _checkChildren (kind, children, value, owner) {
     if (value === undefined) return null
     if (!Array.isArray(value)) throw new Error(`${children.field} must be a list`)
-    return value.map((item) => children.check(item || {}, this, owner))
+    const list = value.map((item) => children.check(item || {}, this, owner))
+    if (kind === 'wireRun' && mixesAcAndDc(list)) throw new Error('A cable cannot carry both AC and DC')
+    return list
   }
 
   _checkWireRunEnds (fields) {
@@ -1025,6 +1043,14 @@ class Store {
       if (unit !== null && !METER_UNITS.includes(unit)) throw new Error(`meter_unit must be one of: ${METER_UNITS.join(', ')}`)
       out = { ...out, meter_unit: unit }
     }
+    if ('current' in out) {
+      const c = out.current === '' || out.current === undefined ? null : out.current
+      if (c !== null && !CURRENTS.includes(c)) throw new Error('current must be one of: ac, dc')
+      out = { ...out, current: c }
+    } else if (creating) {
+      const c = typeCurrent(out.type)
+      if (c) out = { ...out, current: c }
+    }
     for (const key of ['confirm_switching', 'never_remote']) {
       if (key in out) out = { ...out, [key]: out[key] && out[key] !== '0' ? 1 : 0 }
     }