Add given name,state to loadedcomponent list as a loaded component (overwriting existing if needed). **Give it the WHOLE design, the named sheet included.** It replaces that sheet itself, and everything about a sheet that its canvas does not say - its parameters, whether it is the top sheet, and whether it is an ARRAY COMPONENT - can only be carried forward from the copy already in the list. Callers used to filter the sheet out first, which made this lookup dead: while an array component was the sheet being edited, every design built from the model said it was an ordinary sheet, so its ports came out as its drawn IO alone and it was never expanded.

Robust comparison of two schematics. Tolerance determines how similar counts as equal. cannot use equality because float vertices may not be identical use to detemine whether schematic needs to be saved NB for electrical circuit comparison use extractReducedState.

Are two lists of components identical

Are two lists of connections identical **A connection with no vertices on one side is not a difference.** Vertices are a record of a route, and a connection can arrive without one: `extractReducedState` strips them, the sheet DSL writes connections with none so that Issie routes them on load, and a `.dgm` need not have come from this version. In each of those the geometry is not being asserted rather than being asserted to differ, and the wire it names is the same wire between the same two ports. Counting it as changed made a sheet whose route is derived rather than stored report unsaved changes from the moment it opened - which is `currentSheetIsOutOfDate`, so it also prompted on close and drove the auto-backup. Two connections that BOTH carry vertices are compared as before, so an edit that moves a wire is still seen.

Compare the name and IOs of two sheets as loadedcomponents For backups, if these change something major has happened

evil mutable for debugging only allows easy access to specific connections - so it can be highlighted in GUI

The bindings a sheet is resolved with inside one instance of it. An instance binding is an expression in the parameters of the sheet the instance SITS ON, so it is evaluated there first and reaches the child sheet as a plain value; every parameter the instance does not bind takes the child's own declared default. This is the same merge GraphMerger.effectiveBindings makes for elaboration, so what is drawn and what is simulated agree. A binding that cannot be evaluated falls back to the default rather than to nothing.

extract the fields compared to check circuit equality No sheet behind the canvas, so nothing to carry: every caller that HAS one should be calling sheetFromCanvas with it.

Transform the CanvasState into an f# data structure, with layout data removed (for checking electrically significant changes). Components and connections are sorted to make them order-invariant - selecting components alters order.

get sheet I/O labels in correct order based on position of components

the inverse of addStateToLoadedConponents The loadedComponent list in the result does NOT include diagramName A sheet that is not there is an Error rather than an exception because one of the callers runs while rendering: the waveform viewer's buttons ask whether the sheet being simulated still builds, and the sheet named by Model.WaveSimSheet can belong to a project that has since been closed. Raising there threw out of the React render, which unmounted the UI and left every later render throwing the same way - nothing short of reloading the app recovered.

Is circuit (not geometry) the same for two LoadedComponents? They must also have the same name

Is circuit (not geometry) the same for two LoadedComponents? They must also have the same name

Returns true if project exists and ldc is electrically identical to same sheet in project canvasState must be the project currently open state.

Formats a ConnectionId for logging purposes

A sheet's ports where it is known not to be an array design sheet - which is every canvas that has no sheet behind it to carry array settings. See parseDiagramSignatureFor.

Extract the labels and bus widths of the inputs and outputs nodes as a signature. Form is inputs,outputs THE one place that says what a sheet's ports are. On an ordinary sheet they are its Input1 and Output components; on an ARRAY DESIGN SHEET they are derived from its contents and its copy count instead - an Output gives one port per copy, a BusOut one wide one, a loose join an end of a chain - and ArrayExpand.arrayOutlineOf works that out. Every path that asks what a sheet's ports are comes through here, which is what keeps the two kinds of sheet answering one question: loading a sheet, saving one, and CanvasExtractor.signatureOfInstance for an instance of one. The array settings and the parameter slots are taken rather than read off a LoadedComponent because two callers have a canvas and no sheet: an instance's signature is computed from the child sheet's canvas RESOLVED at that instance's bindings, and the sheet-description DSL builds a canvas before there is a sheet to hold it. A sheet whose array settings do not work out - a mux over an Array out that is not there, a channel number that will not evaluate - still has ports, and still has to be drawn while it is being fixed. So the problems are dropped here and CanvasStateAnalyser is what reports them and refuses to simulate: see ArrayExpand's note about nothing there throwing.

A sheet rebuilt from a canvas: everything the canvas says, and everything it cannot say taken from the copy already held. **THE one place that splits a LoadedComponent's fields between those two.** A sheet is more than its canvas - its array settings say how many copies its components are and give it ports no component on it draws, its parameters give those ports their widths, and being the top sheet decides which design is simulated - and Issie rebuilds sheets from canvases in several places. Three of them dropped all of that and produced an ordinary sheet where an array component had been, with the wrong ports and no expansion. Written once so that there is one place to be right, and Tests/Issie.Tests/SheetIdentity.fs holds the two halves to the whole record. `existing` is None only where there genuinely is no sheet behind the canvas.

The signature an instance of `childSheet` has when it binds its parameters as given. None when the child sheet is not in the project.

The signature an instance of `childSheet` has when it binds its parameters as given, and whether its widths are exact. The bindings are read as expressions in `parentBindings` - the parameters of the sheet the instance sits on. Not exact (see signatureIsExact) means some width could not be worked out here, and only the port NAMES may be relied on; the widths are then those the child sheet was saved with. None when the child sheet is not in the project.

The whole design. TopSheet is the flagged top sheet when there is one; otherwise a root of the instantiation forest (a sheet no other sheet instantiates), otherwise the first sheet - the fallback order parameter propagation also uses.

Is circuit (not geometry) the same for two CanvasStates? fast comparison

Every custom component instance in the project sized at its OWN bindings. Resolving a sheet's parameterised slots does not do this. ComponentSlots.setSlotValue writes a CustomCompParam slot into the instance's ParameterBindings, which is all it can reach: the port widths follow from that binding by way of the CHILD sheet, and only signatureOfInstance knows how. So a sheet whose parameter values changed came out of ParameterAnalysis.propagateParameterValues holding instances whose bindings said one width and whose ports still said another. The open sheet never showed it, because ParameterView.updateComponents pushes its slots through ChangeCustom, which recomputes ports on the way. A CLOSED sheet was written to its file as it stood, and opening it raised the instance-out-of-date error that the whole per-instance signature apparatus exists to avoid. Pure, and idempotent: it asks what each instance's ports should be and writes that, so running it again finds nothing to change. A sheet whose canvas it rewrites is flagged as needing saving.

 Put a sheet's parameter slots in order against its canvas, ready to be saved:

   - drop slots naming components that are no longer on the sheet. Every parameter slot must
     name a live component: a slot outliving its component cannot be displayed or edited, and
     pushing a value into it would throw;
   - re-point the label an `IO` slot carries at its component's current label. Nothing rewrites
     that label when the component is renamed, and while no reader depends on it (see
     ParameterTypes.sameSlotName) it is what the properties pane and the slot table print, so a
     stale one describes the sheet wrongly.

Are two lists of vertices are very similar. The lengths are compared FIRST, and not after the fold, because two wires of different lengths are not similar however their common prefix compares - and folding them together first was how this came to raise under .NET, where `List.iter2` is defined only for equal lengths, while returning the right answer in the app, where Fable's stopped at the shorter list. `ListPairs` has since settled that difference in favour of stopping, so the order here is about the answer rather than about raising. Two versions of one connection differ in vertex count whenever the wire has been rerouted, which is the ordinary case for a sheet being edited.

A custom component instance holding the given port widths, matched to its ports by LABEL. Widths only. The ORDER of an instance's ports, and which ports it has, are deliberately left alone: an instance whose ports are in a different order from its sheet's is a correct instance (see CustomCompPorts.instanceIsOutOfDate), and a port added to or removed from the sheet is a change the user is asked to confirm rather than one to make behind them. A label the signature says nothing about therefore keeps the width it had.